diff --git a/configs/vic3d-spd/late-fusion-image/README.md b/configs/vic3d-spd/late-fusion-image/README.md new file mode 100644 index 0000000..b922134 --- /dev/null +++ b/configs/vic3d-spd/late-fusion-image/README.md @@ -0,0 +1,219 @@ +# ImvoxelNet + +## Introduction + +We implement ImvoxelNet to perceive 2D objects from the infrastructure and ego-vehicle sequential images on the VIC-Sync-SPD datasets with MMDetection3D. +We use AB3DMOT to track the objects. + +## Results and models + +| Modality | Fusion | Model | Dataset | AP 3D (Iou=0.5) | AP BEV (Iou=0.5) | MOTA | MOTP | AMOTA | AMOTP | IDs | AB(Byte) | Download | +|----------|-------------|-------------|--------------|-----------------|------------------|--------|--------|--------|--------|-----|----------|-------------------------------------------------------------------------------------------------| +| Image | Veh Only | ImvoxelNet | VIC-Sync-SPD | 8.55 | 10.32 | 10.19 | 57.83 | 1.36 | 14.75 | 4 | | [veh-model](https://drive.google.com/file/d/1eZWsG3VzMuC8swYfVveM3Zg3fcGR6IvN/view?usp=sharing) | +| Image | Late Fusion | ImvoxelNet | VIC-Sync-SPD | 17.31 | 22.53 | 21.81 | 56.67 | 6.22 | 25.24 | 47 | 3300 | [inf-model](https://drive.google.com/file/d/1XntybUfSXQMZgiZnT7INRYPLBuHXT-Lv/view?usp=sharing) | + +--- + +## Detection and Tracking + +### Data Preparation + +**a. Download data and organise as follows** + +Download SPD dataset [here](https://thudair.baai.ac.cn/coop-forecast) and organize as follows: + +``` +# For SPD Dataset located at ${SPD_DATASET_ROOT} +V2X-Seq-SPD/ + └── infrastructure-side # Infrastructure-side data + ├── image + ├── {id}.jpg + ├── velodyne + ├── {id}.pcd + ├── calib + ├── camera_intrinsic # Camera intrinsic parameter + ├── {id}.json + ├── virtuallidar_to_world # Extrinsic parameter from virtual LiDAR coordinate system to world coordinate system + ├── {id}.json + ├── virtuallidar_to_camera # Extrinsic parameter from virtual LiDAR coordinate system to camera coordinate system + ├── {id}.json + ├── label + ├── camera # Labeles in infrastructure virtual LiDAR coordinate system fitting objects in image with image camptured timestamp + ├── {id}.json + ├── virtuallidar # Labeles in infrastructure virtual LiDAR coordinate system fitting objects in point cloud with point cloud captured timestamp + ├── {id}.json + └── data_info.json # More detailed information for each infrastructure-side frame + └── vehicle-side # Vehicle-side data + ├── image + ├── {id}.jpg + ├── velodyne + ├── {id}.pcd + ├── calib + ├── camera_intrinsic # Camera intrinsic parameter + ├── {id}.json + ├── lidar_to_camera # extrinsic parameter from LiDAR coordinate system to camera coordinate system + ├── {id}.json + ├── lidar_to_novatel # extrinsic parameter from LiDAR coordinate system to NovAtel coordinate system + ├── {id}.json + ├── novatel_to_world # location in the world coordinate system + ├── {id}.json + ├── label + ├── camera # Labeles in vehicle LiDAR coordinate system fitting objects in image with image camptured timestamp + ├── {id}.json + ├── lidar # Labeles in vehicle LiDAR coordinate system fitting objects in point cloud with point cloud captured timestamp + ├── {id}.json + └── data_info.json # More detailed information for each vehicle-side frame + └── cooperative # Coopetative-view files + ├── label # Vehicle-infrastructure cooperative (VIC) annotation files. Labeles in vehicle LiDAR coordinate system with the vehicle point cloud timestamp + ├── {id}.json + └── data_info.json # More detailed information for vehicle-infrastructure cooperative frame pair + └── maps # HD Maps for each intersection +``` + +**b. Create a symlink to the dataset root** + +```bash +cd ${DAIR-V2X_ROOT} +ln -s ${SPD_DATASET_ROOT} ./data/V2X-Seq-SPD +``` + +**c. Create Kitti-format data (Option for model training)** + +Data creation should be under the gpu environment. + +```bash +cd ${DAIR-V2X_ROOT} +python tools/dataset_converter/spd2kitti_detection/dair2kitti.py \ + --source-root ./data/V2X-Seq-SPD/infrastructure-side \ + --target-root ./data/V2X-Seq-SPD/infrastructure-side \ + --split-path ./data/split_datas/cooperative-split-data-spd.json \ + --label-type lidar \ + --sensor-view infrastructure \ + --no-classmerge +python tools/dataset_converter/spd2kitti_detection/dair2kitti.py \ + --source-root ./data/V2X-Seq-SPD/vehicle-side \ + --target-root ./data/V2X-Seq-SPD/vehicle-side \ + --split-path ./data/split_datas/cooperative-split-data-spd.json \ + --label-type lidar \ + --sensor-view vehicle \ + --no-classmerge +``` + +In the end, the data and info files should be organized as follows: + +``` +V2X-Seq-SPD/ + └──── infrastructure-side + ├───── image + ├───── velodyne + ├───── calib + ├───── label + ├───── data_info.json + ├───── ImageSets + └──── training + ├───── image_2 + ├───── velodyne + ├───── label_2 + └───── calib + └──── testing + ├───── vehicle-side + ├───── image + ├───── velodyne + ├───── calib + ├───── label + ├───── data_info.json + ├───── ImageSets + └──── training + ├───── image_2 + ├───── velodyne + ├───── label_2 + └───── calib + └──── testing + └──── cooperative + ├───── label_world + └───── data_info.json +``` + +**d. Convert V2X-Seq-SPD cooperative label to V2X-Seq-SPD-KITTI format (Option for tracking evaluation)** + +```bash +cd ${DAIR-V2X_ROOT} +python tools/dataset_converter/spd2kitti_tracking/coop_label_dair2kitti.py \ + --source-root ./data/V2X-Seq-SPD \ + --target-root ./data/V2X-Seq-SPD-KITTI/cooperative \ + --split-path ./data/split_datas/cooperative-split-data-spd.json \ + --no-classmerge +``` + +In the end, the data and info files should be organized as follows: + +``` +V2X-Seq-SPD-KITTI/ + └──── cooperative + ├──── training + ├──── {sequence_id} + ├──── label_02 + ├───── {sequence_id}.txt + ├──── validation + └──── testing +``` + +* VIC-Sync-SPD Dataset. VIC-Sync-SPD dataset is extracted from V2X-Seq-SPD, which is composed of 15,371 pairs of infrastructure and vehicle frames as well as their cooperative annotations as ground truth. + We split V2X-Seq-SPD dataset to train/valid/test part as 5:2:3 respectively. + Please refer [split data](../../../data/split_datas/cooperative-split-data-spd.json) for the splitting file. + +### Detection Training + +* Implementation Framework. We directly use MMDetection3D (v0.17.1) to train the infrastructure 3D detector and vehicle 3D detector. + +* Infrastructure detector training details. + Before training the detectors, we should follow MMDetection3D to convert the "./data/V2X-Seq-SPD/infrastructure-side" into specific training format. + Then we train the PointPillars with configure file [trainval_config_i.py](./trainval_config_i.py) + +* Vehicle detector training details. + Before training the detectors, we should follow MMDetection3D to convert the "./data/V2X-Seq-SPD/vehicle-side" into specific training format. + Then we train the PointPillars with configure file [trainval_config_v.py](./trainval_config_v.py) + +### Evaluation + +**a. Detection Checkpoint Preparation** + +Download checkpoints of ImvoxelNet trained on V2X-Seq-SPD datasets with mmdetection3d from Google drive: [inf-model](https://drive.google.com/file/d/1XntybUfSXQMZgiZnT7INRYPLBuHXT-Lv/view?usp=sharing) & [veh-model](https://drive.google.com/file/d/1eZWsG3VzMuC8swYfVveM3Zg3fcGR6IvN/view?usp=sharing). + +Put the checkpoints under [this folder](./imvoxelnet). +The file structure should be like: + +``` +DAIR-V2X/configs/vic3d-spd/late-fusion-image/imvoxelnet/ + ├──trainval_config_i.py + ├──vic3d_latefusion_imvoxelnet_i.pth + ├──trainval_config_v.py + ├──vic3d_latefusion_imvoxelnet_v.pth +``` + +**b. Run the following commands for evaluation** + +```bash +# bash scripts/eval_camera_late_fusion_spd.sh [CUDA_VISIBLE_DEVICES] [DELAY_K] [EXTEND_RANGE_START] [EXTEND_RANGE_END] [TIME_COMPENSATION] +cd ${DAIR-V2X_ROOT}/v2x +bash scripts/eval_camera_late_fusion_spd.sh 0 0 0 100 --no-comp +``` + +The parameters are: + +- **CUDA_VISIBLE_DEVICES**: GPU IDs +- **DELAY_K**: the number of previous frames for `vic-async-spd` dataset. `vic-async-spd-0` is equivalent to `vic-sync-spd` dataset. +- **EXTEND_RANGE_START**: x_{min} of the interested area of vehicle-egocentric surroundings at Vehicle LiDAR +- **EXTEND_RANGE_END**: x_{max} of the interested area of vehicle-egocentric surroundings at Vehicle LiDAR +- **TIME_COMPENSATION**: for `late_fusion`, you can remove the time compensation module by an addtional argument **--no-comp** + +If everything is prepared properly, the output results should be: + +``` +car 3d IoU threshold 0.50, Average Precision = 17.31 +car bev IoU threshold 0.50, Average Precision = 22.53 +AMOTA = 0.0622 +AMOTP = 0.2524 + +``` +Tracking evaluation results directory: ${DAIR-V2X_ROOT}/output/spd_late_camera/tracking_evaluation_results diff --git a/configs/vic3d-spd/late-fusion-image/imvoxelnet/README.md b/configs/vic3d-spd/late-fusion-image/imvoxelnet/README.md new file mode 100644 index 0000000..67ad833 --- /dev/null +++ b/configs/vic3d-spd/late-fusion-image/imvoxelnet/README.md @@ -0,0 +1,194 @@ +# ImvoxelNet + +## Introduction + +We implement ImvoxelNet and provide the results and checkpoints on VIC-Sync-SPD datasets with MMDetection3D. + +## Results and models + +| Modality | Fusion | Model | Dataset | AP 3D (Iou=0.5) | AP BEV (Iou=0.5) | AB(Byte) | Download | +|----------|-------------|-------------|--------------|-----------------|------------------|----------|-------------------------------------------------------------------------------------------------| +| Image | Veh Only | ImvoxelNet | VIC-Sync-SPD | 8.55 | 10.32 | | [veh-model](https://drive.google.com/file/d/1eZWsG3VzMuC8swYfVveM3Zg3fcGR6IvN/view?usp=sharing) | +| Image | Late Fusion | ImvoxelNet | VIC-Sync-SPD | 17.31 | 22.53 | 3300 | [inf-model](https://drive.google.com/file/d/1XntybUfSXQMZgiZnT7INRYPLBuHXT-Lv/view?usp=sharing) | + +--- + +## Detection + +### Data Preparation + +**a. Download data and organise as follows** + +Download SPD dataset [here](https://thudair.baai.ac.cn/coop-forecast) and organize as follows: + +``` +# For SPD Dataset located at ${SPD_DATASET_ROOT} +V2X-Seq-SPD/ + └── infrastructure-side # Infrastructure-side data + ├── image + ├── {id}.jpg + ├── velodyne + ├── {id}.pcd + ├── calib + ├── camera_intrinsic # Camera intrinsic parameter + ├── {id}.json + ├── virtuallidar_to_world # Extrinsic parameter from virtual LiDAR coordinate system to world coordinate system + ├── {id}.json + ├── virtuallidar_to_camera # Extrinsic parameter from virtual LiDAR coordinate system to camera coordinate system + ├── {id}.json + ├── label + ├── camera # Labeles in infrastructure virtual LiDAR coordinate system fitting objects in image with image camptured timestamp + ├── {id}.json + ├── virtuallidar # Labeles in infrastructure virtual LiDAR coordinate system fitting objects in point cloud with point cloud captured timestamp + ├── {id}.json + └── data_info.json # More detailed information for each infrastructure-side frame + └── vehicle-side # Vehicle-side data + ├── image + ├── {id}.jpg + ├── velodyne + ├── {id}.pcd + ├── calib + ├── camera_intrinsic # Camera intrinsic parameter + ├── {id}.json + ├── lidar_to_camera # extrinsic parameter from LiDAR coordinate system to camera coordinate system + ├── {id}.json + ├── lidar_to_novatel # extrinsic parameter from LiDAR coordinate system to NovAtel coordinate system + ├── {id}.json + ├── novatel_to_world # location in the world coordinate system + ├── {id}.json + ├── label + ├── camera # Labeles in vehicle LiDAR coordinate system fitting objects in image with image camptured timestamp + ├── {id}.json + ├── lidar # Labeles in vehicle LiDAR coordinate system fitting objects in point cloud with point cloud captured timestamp + ├── {id}.json + └── data_info.json # More detailed information for each vehicle-side frame + └── cooperative # Coopetative-view files + ├── label # Vehicle-infrastructure cooperative (VIC) annotation files. Labeles in vehicle LiDAR coordinate system with the vehicle point cloud timestamp + ├── {id}.json + └── data_info.json # More detailed information for vehicle-infrastructure cooperative frame pair + └── maps # HD Maps for each intersection +``` + +**b. Create a symlink to the dataset root** + +```bash +cd ${DAIR-V2X_ROOT} +ln -s ${SPD_DATASET_ROOT} ./data/V2X-Seq-SPD +``` + +**c. Create Kitti-format data (Option for model training)** + +Data creation should be under the gpu environment. + +```bash +cd ${DAIR-V2X_ROOT} +python tools/dataset_converter/spd2kitti_detection/dair2kitti.py \ + --source-root ./data/V2X-Seq-SPD/infrastructure-side \ + --target-root ./data/V2X-Seq-SPD/infrastructure-side \ + --split-path ./data/split_datas/cooperative-split-data-spd.json \ + --label-type lidar \ + --sensor-view infrastructure \ + --no-classmerge +python tools/dataset_converter/spd2kitti_detection/dair2kitti.py \ + --source-root ./data/V2X-Seq-SPD/vehicle-side \ + --target-root ./data/V2X-Seq-SPD/vehicle-side \ + --split-path ./data/split_datas/cooperative-split-data-spd.json \ + --label-type lidar \ + --sensor-view vehicle \ + --no-classmerge +``` + +In the end, the data and info files should be organized as follows: + +``` +V2X-Seq-SPD/ + └──── infrastructure-side + ├───── image + ├───── velodyne + ├───── calib + ├───── label + ├───── data_info.json + ├───── ImageSets + └──── training + ├───── image_2 + ├───── velodyne + ├───── label_2 + └───── calib + └──── testing + ├───── vehicle-side + ├───── image + ├───── velodyne + ├───── calib + ├───── label + ├───── data_info.json + ├───── ImageSets + └──── training + ├───── image_2 + ├───── velodyne + ├───── label_2 + └───── calib + └──── testing + └──── cooperative + ├───── label_world + └───── data_info.json +``` + +* VIC-Sync-SPD Dataset. VIC-Sync-SPD dataset is extracted from V2X-Seq-SPD, which is composed of 15,371 pairs of infrastructure and vehicle frames as well as their cooperative annotations as ground truth. + We split V2X-Seq-SPD dataset to train/valid/test part as 5:2:3 respectively. + Please refer [split data](../../../data/split_datas/cooperative-split-data-spd.json) for the splitting file. + +### Training & Evaluation + +#### Training + +* Implementation Framework. We directly use MMDetection3D (v0.17.1) to train the infrastructure 3D detector and vehicle 3D detector. + +* Infrastructure detector training details. + Before training the detectors, we should follow MMDetection3D to convert the "./data/V2X-Seq-SPD/infrastructure-side" into specific training format. + Then we train the PointPillars with configure file [trainval_config_i.py](./trainval_config_i.py) + +* Vehicle detector training details. + Before training the detectors, we should follow MMDetection3D to convert the "./data/V2X-Seq-SPD/vehicle-side" into specific training format. + Then we train the PointPillars with configure file [trainval_config_v.py](./trainval_config_v.py) + +#### Evaluation + +**a. Detection Checkpoint Preparation** + +Download checkpoints of ImvoxelNet trained on V2X-Seq-SPD datasets with mmdetection3d from Google drive: [inf-model](https://drive.google.com/file/d/1XntybUfSXQMZgiZnT7INRYPLBuHXT-Lv/view?usp=sharing) & [veh-model](https://drive.google.com/file/d/1eZWsG3VzMuC8swYfVveM3Zg3fcGR6IvN/view?usp=sharing). + +Put the checkpoints under [this folder](./imvoxelnet). +The file structure should be like: + +``` +DAIR-V2X/configs/vic3d-spd/late-fusion-image/imvoxelnet/ + ├──trainval_config_i.py + ├──vic3d_latefusion_imvoxelnet_i.pth + ├──trainval_config_v.py + ├──vic3d_latefusion_imvoxelnet_v.pth +``` + +**b. Run the following commands for evaluation** + +```bash +cd ${DAIR-V2X_ROOT}/v2x +bash scripts/eval_camera_late_fusion_spd.sh 0 0 0 100 --no-comp true +``` + +The parameters are: + +- **CUDA_VISIBLE_DEVICES**: GPU IDs +- **DELAY_K**: the number of previous frames for `vic-async-spd` dataset. `vic-async-spd-0` is equivalent to `vic-sync-spd` dataset +- **EXTEND_RANGE_START**: x_{min} of the interested area of vehicle-egocentric surroundings at Vehicle LiDAR +- **EXTEND_RANGE_END**: x_{max} of the interested area of vehicle-egocentric surroundings at Vehicle LiDAR +- **TIME_COMPENSATION**: for `late_fusion`, you can remove the time compensation module by an addtional argument **--no-comp** +- **ONLY_DTC**: only eva detection results + + +If everything is prepared properly, the output results should be: + +``` +car 3d IoU threshold 0.50, Average Precision = 17.31 +car bev IoU threshold 0.50, Average Precision = 22.53 + +``` \ No newline at end of file diff --git a/configs/vic3d-spd/late-fusion-image/imvoxelnet/trainval_config_i.py b/configs/vic3d-spd/late-fusion-image/imvoxelnet/trainval_config_i.py new file mode 100644 index 0000000..966eb1b --- /dev/null +++ b/configs/vic3d-spd/late-fusion-image/imvoxelnet/trainval_config_i.py @@ -0,0 +1,170 @@ +dataset_type = 'KittiDataset' +data_root = '../../../../data/V2X-Seq-SPD/infrastructure-side/' +class_names = ['Car'] +input_modality = dict(use_lidar=False, use_camera=True) +point_cloud_range = [0, -39.68, -3, 92.16, 39.68, 1] +voxel_size = [0.32, 0.32, 0.33] +length = int((point_cloud_range[3] - point_cloud_range[0]) / voxel_size[0]) +width = int((point_cloud_range[4] - point_cloud_range[1]) / voxel_size[1]) +height = int((point_cloud_range[5] - point_cloud_range[2]) / voxel_size[2]) +output_shape = [width, length, height] +img_norm_cfg = dict( + mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True) +img_scale = (960, 540) +img_resize_scale = [(912, 513), (1008, 567)] + +work_dir = './work_dirs/vic3d_latefusion_inf_imvoxelnet' + +model = dict( + type='ImVoxelNet', + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=False), + norm_eval=True, + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50'), + style='pytorch'), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=64, + num_outs=4), + neck_3d=dict(type='OutdoorImVoxelNeck', in_channels=64, out_channels=256), + bbox_head=dict( + type='Anchor3DHead', + num_classes=1, + in_channels=256, + feat_channels=256, + use_direction_classifier=True, + anchor_generator=dict( + type='AlignedAnchor3DRangeGenerator', + ranges=[[0, -39.68, -1.78, 92.16, 39.68, -1.78]], + sizes=[[3.9, 1.6, 1.56]], + rotations=[0, 1.57], + reshape_out=True), + diff_rad_by_sin=True, + bbox_coder=dict(type='DeltaXYZWLHRBBoxCoder'), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=2.0), + loss_dir=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.2)), + n_voxels=output_shape, + anchor_generator=dict( + type='AlignedAnchor3DRangeGenerator', + ranges=[[0, -39.68, -3.08, 92.16, 39.68, 0.76]], + rotations=[.0]), + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + iou_calculator=dict(type='BboxOverlapsNearest3D'), + pos_iou_thr=0.6, + neg_iou_thr=0.45, + min_pos_iou=0.45, + ignore_iof_thr=-1), + allowed_border=0, + pos_weight=-1, + debug=False), + test_cfg=dict( + use_rotate_nms=True, + nms_across_levels=False, + nms_thr=0.01, + score_thr=0.1, + min_bbox_size=0, + nms_pre=100, + max_num=50)) + +train_pipeline = [ + dict(type='LoadAnnotations3D'), + dict(type='LoadImageFromFile'), + dict(type='RandomFlip3D', flip_ratio_bev_horizontal=0.5), + dict( + type='Resize', + img_scale=img_resize_scale, + keep_ratio=True, + multiscale_mode='range'), + dict(type='Normalize', **img_norm_cfg), + dict(type='Pad', size_divisor=32), + dict(type='ObjectRangeFilter', point_cloud_range=point_cloud_range), + dict(type='DefaultFormatBundle3D', class_names=class_names), + dict(type='Collect3D', keys=['img', 'gt_bboxes_3d', 'gt_labels_3d']) +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='Resize', img_scale=img_scale, keep_ratio=True), + dict(type='Normalize', **img_norm_cfg), + dict(type='Pad', size_divisor=32), + dict( + type='DefaultFormatBundle3D', + class_names=class_names, + with_label=False), + dict(type='Collect3D', keys=['img']) +] + +data = dict( + samples_per_gpu=1, + workers_per_gpu=1, + train=dict( + type='RepeatDataset', + times=1, + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file=data_root + 'kitti_infos_train.pkl', + split='training', + pts_prefix='velodyne_reduced', + pipeline=train_pipeline, + modality=input_modality, + classes=class_names, + test_mode=False)), + val=dict( + type=dataset_type, + data_root=data_root, + ann_file=data_root + 'kitti_infos_val.pkl', + split='training', + pts_prefix='velodyne_reduced', + pipeline=test_pipeline, + modality=input_modality, + classes=class_names, + test_mode=True), + test=dict( + type=dataset_type, + data_root=data_root, + ann_file=data_root + 'kitti_infos_val.pkl', + split='training', + pts_prefix='velodyne_reduced', + pipeline=test_pipeline, + modality=input_modality, + classes=class_names, + box_type_3d="Lidar", + test_mode=True)) + +optimizer = dict( + type='AdamW', + lr=0.0001, + weight_decay=0.0001, + paramwise_cfg=dict( + custom_keys={'backbone': dict(lr_mult=0.1, decay_mult=1.0)})) +optimizer_config = dict(grad_clip=dict(max_norm=35., norm_type=2)) +lr_config = dict(policy='step', step=[8, 11]) +total_epochs = 12 + +checkpoint_config = dict(interval=1, max_keep_ckpts=1) +log_config = dict( + interval=50, + hooks=[dict(type='TextLoggerHook'), + dict(type='TensorboardLoggerHook')]) +evaluation = dict(interval=1) +dist_params = dict(backend='nccl') +find_unused_parameters = True # only 1 of 4 FPN outputs is used +log_level = 'INFO' +load_from = None +resume_from = None +workflow = [('train', 1)] \ No newline at end of file diff --git a/configs/vic3d-spd/late-fusion-image/imvoxelnet/trainval_config_v.py b/configs/vic3d-spd/late-fusion-image/imvoxelnet/trainval_config_v.py new file mode 100644 index 0000000..db91f65 --- /dev/null +++ b/configs/vic3d-spd/late-fusion-image/imvoxelnet/trainval_config_v.py @@ -0,0 +1,171 @@ +dataset_type = 'KittiDataset' +data_root = '../../../../data/V2X-Seq-SPD/vehicle-side/' +class_names = ['Car'] +input_modality = dict(use_lidar=False, use_camera=True) +point_cloud_range = [0, -39.68, -3, 92.16, 39.68, 1] +voxel_size = [0.32, 0.32, 0.33] +length = int((point_cloud_range[3] - point_cloud_range[0]) / voxel_size[0]) +width = int((point_cloud_range[4] - point_cloud_range[1]) / voxel_size[1]) +height = int((point_cloud_range[5] - point_cloud_range[2]) / voxel_size[2]) +output_shape = [width, length, height] +img_norm_cfg = dict( + mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True) +img_scale = (960, 540) +img_resize_scale = [(912, 513), (1008, 567)] + +work_dir = './work_dirs/vic3d_latefusion_veh_imvoxelnet' + +model = dict( + type='ImVoxelNet', + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=False), + norm_eval=True, + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50'), + style='pytorch'), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=64, + num_outs=4), + neck_3d=dict(type='OutdoorImVoxelNeck', in_channels=64, out_channels=256), + bbox_head=dict( + type='Anchor3DHead', + num_classes=1, + in_channels=256, + feat_channels=256, + use_direction_classifier=True, + anchor_generator=dict( + type='AlignedAnchor3DRangeGenerator', + ranges=[[0, -39.68, -1.78, 92.16, 39.68, -1.78]], + sizes=[[3.9, 1.6, 1.56]], + rotations=[0, 1.57], + reshape_out=True), + diff_rad_by_sin=True, + bbox_coder=dict(type='DeltaXYZWLHRBBoxCoder'), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=2.0), + loss_dir=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.2)), + n_voxels=output_shape, + anchor_generator=dict( + type='AlignedAnchor3DRangeGenerator', + ranges=[[0, -39.68, -3.08, 92.16, 39.68, 0.76]], + rotations=[.0]), + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + iou_calculator=dict(type='BboxOverlapsNearest3D'), + pos_iou_thr=0.6, + neg_iou_thr=0.45, + min_pos_iou=0.45, + ignore_iof_thr=-1), + allowed_border=0, + pos_weight=-1, + debug=False), + test_cfg=dict( + use_rotate_nms=True, + nms_across_levels=False, + nms_thr=0.01, + score_thr=0.1, + min_bbox_size=0, + nms_pre=100, + max_num=50)) + +train_pipeline = [ + dict(type='LoadAnnotations3D'), + dict(type='LoadImageFromFile'), + dict(type='RandomFlip3D', flip_ratio_bev_horizontal=0.5), + dict( + type='Resize', + img_scale=img_resize_scale, + keep_ratio=True, + multiscale_mode='range'), + dict(type='Normalize', **img_norm_cfg), + dict(type='Pad', size_divisor=32), + dict(type='ObjectRangeFilter', point_cloud_range=point_cloud_range), + dict(type='DefaultFormatBundle3D', class_names=class_names), + dict(type='Collect3D', keys=['img', 'gt_bboxes_3d', 'gt_labels_3d']) +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='Resize', img_scale=img_scale, keep_ratio=True), + dict(type='Normalize', **img_norm_cfg), + dict(type='Pad', size_divisor=32), + dict( + type='DefaultFormatBundle3D', + class_names=class_names, + with_label=False), + dict(type='Collect3D', keys=['img']) +] + +data = dict( + samples_per_gpu=4, + workers_per_gpu=4, + train=dict( + type='RepeatDataset', + times=3, + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file=data_root + 'kitti_infos_train.pkl', + split='training', + pts_prefix='velodyne_reduced', + pipeline=train_pipeline, + modality=input_modality, + classes=class_names, + test_mode=False)), + val=dict( + type=dataset_type, + data_root=data_root, + ann_file=data_root + 'kitti_infos_val.pkl', + split='training', + pts_prefix='velodyne_reduced', + pipeline=test_pipeline, + modality=input_modality, + classes=class_names, + test_mode=True), + test=dict( + type=dataset_type, + data_root=data_root, + ann_file=data_root + 'kitti_infos_val.pkl', + split='training', + pts_prefix='velodyne_reduced', + pipeline=test_pipeline, + modality=input_modality, + classes=class_names, + box_type_3d="Lidar", + test_mode=True)) + +optimizer = dict( + type='AdamW', + lr=0.0001, + weight_decay=0.0001, + paramwise_cfg=dict( + custom_keys={'backbone': dict(lr_mult=0.1, decay_mult=1.0)})) +optimizer_config = dict(grad_clip=dict(max_norm=35., norm_type=2)) +lr_config = dict(policy='step', step=[8, 11]) +total_epochs = 12 + +checkpoint_config = dict(interval=1, max_keep_ckpts=1) +log_config = dict( + interval=50, + hooks=[dict(type='TextLoggerHook'), + dict(type='TensorboardLoggerHook')]) +evaluation = dict(interval=1) +dist_params = dict(backend='nccl') +find_unused_parameters = True # only 1 of 4 FPN outputs is used +log_level = 'INFO' +load_from = None +resume_from = None +workflow = [('train', 1)] + diff --git a/data/split_datas/cooperative-split-data-spd.json b/data/split_datas/cooperative-split-data-spd.json new file mode 100644 index 0000000..8c8e4d1 --- /dev/null +++ b/data/split_datas/cooperative-split-data-spd.json @@ -0,0 +1 @@ +{"batch_split": {"train": ["0000", "0001", "0002", "0004", "0005", "0008", "0010", "0016", "0018", "0022", "0023", "0025", "0029", "0030", "0032", "0033", "0034", "0035", "0036", "0037", "0040", "0041", "0047", "0048", "0049", "0050", "0054", "0055", "0056", "0057", "0060", "0062", "0066", "0068", "0070", "0072", "0077", "0078", "0079", "0080", "0081", "0082", "0084", "0087", "0093", "0094"], "val": ["0003", "0007", "0014", "0015", "0017", "0020", "0021", "0042", "0052", "0058", "0059", "0061", "0063", "0071", "0073", "0075", "0085", "0086", "0088", "0089", "0092"], "test": ["0006", "0009", "0011", "0012", "0013", "0019", "0024", "0026", "0027", "0028", "0031", "0038", "0039", "0043", "0044", "0045", "0046", "0051", "0053", "0064", "0065", "0067", "0069", "0074", "0076", "0083", "0090", "0091"], "test_A": ["0009", "0013", "0026", "0038", "0044", "0067", "0076", "0091"]}, "vehicle_split": {"train": ["000000", "000001", "000002", "000003", "000004", "000005", "000006", "000007", "000008", "000009", "000010", "000011", "000012", "000013", "000014", "000015", "000016", "000017", "000018", "000019", "000020", "000021", "000022", "000023", "000024", "000025", "000026", "000027", "000028", "000029", "000030", "000031", "000032", "000033", "000034", "000035", "000036", "000037", "000038", "000039", "000040", "000041", "000042", "000043", "000044", "000045", "000046", "000047", "000048", "000049", "000050", "000051", "000052", "000053", "000054", "000055", "000056", "000057", "000058", "000059", "000060", "000061", "000062", "000063", "000064", "000065", "000066", "000067", "000068", "000069", "000070", "000071", "000072", "000073", "000074", "000075", "000076", "000077", "000078", "000079", "000080", "000081", "000082", "000083", "000084", "000085", "000086", "000087", "000088", "000089", "000090", "000091", "000092", "000093", "000094", "000095", "000096", "000097", "000098", "000099", "000100", "000101", "000102", "000103", "000104", "000105", "000106", "000107", "000108", "000109", "000110", "000111", "000112", "000113", "000114", "000115", "000116", "000117", "000118", "000119", "000120", "000121", "000122", "000123", "000124", "000125", "000126", "000127", "000128", "000129", "000130", "000131", "000132", "000133", "000134", "000135", "000136", "000137", "000138", "000139", "000140", "000141", "000142", "000143", "000144", "000145", "000146", "000147", "000148", "000149", "000150", "000151", "000152", "000153", "000154", "000155", "000156", "000157", "000158", "000159", "000160", "000161", "000162", "000163", "000164", "000165", "000166", "000167", "000168", "000169", "000170", "000171", "000172", "000173", "000174", "000175", "000176", "000177", "000178", "000179", "000180", "000181", "000182", "000183", "000184", "000185", "000186", "000187", "000188", "000189", "000190", "000191", "000192", "000193", "000194", "000195", "000196", "000197", "000198", "000199", "000200", "000201", "000202", "000203", "000204", "000205", "000206", "000207", "000208", "000209", "000210", "000211", "000212", "000213", "000214", "000215", "000216", "000217", "000218", "000219", "000220", "000221", "000222", "000223", "000224", "000225", "000226", "000227", "000228", "000229", "000230", "000231", "000232", "000233", "000234", "000235", "000236", "000237", "000238", "000239", "000240", "000241", "000242", "000243", "000244", "000245", "000246", "000247", "000248", "000249", "000250", "000251", "000252", "000253", "000254", "000255", "000256", "000257", "000258", "000259", "000260", "000261", "000262", "000263", "000264", "000265", "000266", "000267", "000268", "000269", "000270", "000271", "000272", "000273", "000274", "000275", "000276", "000277", "000278", "000279", "000280", "000281", "000282", "000283", "000284", "000285", "000286", "000287", "000288", "000289", "000290", "000291", "000292", "000293", "000294", "000295", "000296", "000297", "000298", "000299", "000300", "000301", "000302", "000303", "000304", "000305", "000306", "000307", "000308", "000309", "000310", "000311", "000312", "000313", "000314", "000315", "000316", "000317", "000318", "000319", "000320", "000321", "000322", "000323", "000324", "000325", "000326", "000327", "000328", "000329", "000330", "000331", "000332", "000333", "000334", "000335", "000336", "000337", "000338", "000339", "000340", "000341", "000342", "000343", "000344", "000345", "000346", "000347", "000348", "000349", "000350", "000351", "000352", "000353", "000354", "000355", "000356", "000357", "000358", "000359", "000360", "000361", "000362", "000363", "000364", "000365", "000366", "000367", "000368", "000369", "000370", "000371", "000372", "000373", "000374", "000375", "000376", "000377", "000378", "000379", "000380", "000381", "000382", "000383", "000384", "000385", "000386", "000387", "000388", "000389", "000390", "000391", "000392", "000393", "000394", "000395", "000396", "000397", "000398", "000399", "000400", "000401", "000402", "000403", "000404", "000405", "000406", "000407", "000408", "000409", "000410", "000411", "000412", "000413", "000414", "000415", "000416", "000417", "000418", "000419", "000420", "000421", "000422", "000423", "000424", "000425", "000426", "000427", "000428", "000429", "000430", "000431", "000432", "000433", "000434", "000435", "000436", "000437", "000438", "000439", "000440", "000441", "000442", "000443", "000444", "000445", "000446", "000447", "000448", "000449", "000450", "000451", "000452", "000453", "000454", "000455", "000456", "000457", "000458", "000459", "000460", "000461", "000462", "000463", "000464", "000465", "000466", "000467", "000468", "000469", "000470", "000471", "000472", "000473", "000474", "000475", "000476", "000477", "000478", "000479", "000480", "000481", "000482", "000483", "000484", "000485", "000486", "000487", "000488", "000489", "000490", "000491", "000492", "000493", "000494", "000495", "000496", "000497", "000498", "000499", "000500", "000501", "000502", "000503", "000504", "000505", "000506", "000507", "000508", "000509", "000510", "000511", "000512", "000513", "000514", "000515", "000516", "000517", "000518", "000519", "000520", "000521", "000522", "000523", "000524", "000525", "000526", "000527", "000528", "000529", "000530", "000531", "000532", "000533", "000534", "000535", "000536", "000537", "000538", "000539", "000540", "000541", "000542", "000543", "000544", "000545", "000546", "000547", "000548", "000549", "000550", "000551", "000552", "000553", "000554", "000555", "000556", "000557", "000558", "000559", "000560", "000561", "000562", "000563", "000564", "000565", "000566", "000567", "000568", "000569", "000570", "000571", "000572", "000573", "000574", "000575", "000576", "000577", "000578", "000579", "000580", "000581", "000582", "000583", "000584", "000585", "000586", "000587", "000588", "000589", "000590", "000591", "000592", "000593", "000594", "000595", "000596", "000597", "000598", "000599", "000600", "000601", "000602", "000603", "000604", "000605", "000606", "000607", "000608", "000609", "000610", "000611", "000612", "000613", "000614", "000615", "000616", "000617", "000618", "000619", "000620", "000621", "000622", "000623", "000624", "000625", "000626", "000627", "000628", "000629", "000630", "000631", "000632", "000633", "000634", "000635", "000636", "000637", "000638", "000639", "000640", "000641", "000642", "000643", "000644", "000645", "000646", "000647", "000648", "000649", "000650", "000651", "000652", "000653", "000654", "000655", "000656", "000657", "000658", "000659", "000660", "000661", "000662", "000663", "000664", "000665", "000666", "000667", "000668", "000669", "000670", "000671", "000672", "000673", "000674", "000675", "000676", "000677", "000678", "000679", "000680", "000681", "000682", "000683", "000684", "000685", "000686", "000687", "000688", "000689", "000690", "000691", "000692", "000693", "000694", "000695", "000696", "000697", "000698", "000699", "000700", "000701", "000702", "000703", "000704", "000705", "000706", "000707", "000708", "000709", "000710", "000711", "000712", "000713", "000714", "000715", "000716", "000717", "000718", "000719", "000720", "000721", "000722", "000723", "000724", "000725", "000726", "000727", "000728", "000729", "000730", "000731", "000732", "000733", "000734", "000735", "000736", "000737", "000738", "000739", "000740", "000741", "000742", "000743", "000744", "000745", "000746", "000747", "000748", "000749", "000750", "000751", "000752", "000753", "000754", "000755", "000756", "000757", "000758", "000759", "000760", "000761", "000762", "000763", "000764", "000765", "000766", "000767", "000768", "000769", "000770", "000771", "000772", "000773", "000774", "000775", "000776", "000777", "000778", "000779", "000780", "000781", "000782", "000783", "000784", "000785", "000786", "000787", "000788", "000789", "000790", "000791", "000792", "000793", "000794", "000795", "000796", "000797", "000798", "000799", "000800", "000801", "000802", "000803", "000804", "000805", "000806", "000807", "000808", "000809", "000810", "000811", "000812", "000813", "000814", "000815", "000816", "000817", "000818", "000819", "000820", "000821", "000822", "000823", "000824", "000825", "000826", "000827", "000828", "000829", "000830", "000831", "000832", "000833", "000834", "000835", "000836", "000837", "000838", "000839", "000840", "000841", "000842", "000843", "000844", "000845", "000846", "000847", "000848", "000849", "000850", "000851", "000852", "000853", "000854", "000855", "000856", "000857", "000858", "000859", "000860", "000861", "000862", "000863", "000864", "000865", "000866", "000867", "000868", "001078", "001079", "001080", "001081", "001082", "001083", "001084", "001085", "001086", "001087", "001088", "001089", "001090", "001091", "001092", "001093", "001094", "001095", "001096", "001097", "001098", "001099", "001100", "001101", "001102", "001103", "001104", "001105", "001106", "001107", "001108", "001109", "001110", "001111", "001112", "001113", "001114", "001115", "001116", "001117", "001118", "001119", "001120", "001121", "001122", "001123", "001124", "001125", "001126", "001127", "001128", "001129", "001130", "001131", "001132", "001133", "001134", "001135", "001136", "001137", "001138", "001139", "001140", "001141", "001142", "001143", "001144", "001145", "001146", "001147", "001148", "001149", "001150", "001151", "001152", "001153", "001154", "001155", "001156", "001157", "001158", "001159", "001160", "001161", "001162", "001163", "001164", "001165", "001166", "001167", "001168", "001169", "001170", "001171", "001172", "001173", "001174", "001175", "001176", "001177", "001178", "001179", "001180", "001181", "001182", "001183", "001184", "001185", "001186", "001187", "001188", "001189", "001190", "001191", "001192", "001193", "001194", "001195", "001196", "001197", "001198", "001199", "001200", "001201", "001202", "001203", "001204", "001205", "001206", "001207", "001208", "001209", "001210", "001211", "001212", "001213", "001214", "001215", "001216", "001217", "001218", "001219", "001220", "001221", "001222", "001223", "001224", "001225", "001226", "001227", "001228", "001229", "001230", "001231", "001232", "001233", "001234", "001235", "001236", "001237", "001238", "001239", "001240", "001241", "001242", "001243", "001244", "001245", "001246", "001247", "001248", "001249", "001250", "001251", "001252", "001253", "001254", "001255", "001256", "001257", "001258", "001259", "001260", "001261", "001262", "001263", "001264", "001265", "001266", "001267", "001268", "001269", "001270", "001271", "001272", "001273", "001274", "001275", "001276", "001277", "001278", "001279", "001280", "001281", "001282", "001283", "001284", "001285", "001286", "001287", "001288", "001289", "001290", "001291", "001292", "001293", "001294", "001295", "001296", "001297", "001298", "001299", "001300", "001301", "001302", "001303", "001304", "001305", "001306", "001307", "001308", "001309", "001310", "001311", "001312", "001313", "001314", "001315", "001316", "001317", "001318", "001319", "001320", "001321", "001322", "001323", "001324", "001325", "001326", "001327", "001328", "001329", "001330", "001331", "001332", "001333", "001334", "001335", "001336", "001337", "001338", "001339", "001340", "001341", "001342", "001343", "001344", "001345", "001346", "001347", "001348", "001349", "001350", "001351", "001352", "001353", "001354", "001355", "001356", "001357", "001358", "001359", "001360", "001361", "001362", "001363", "001364", "001365", "001366", "001367", "001368", "001369", "001370", "001371", "001372", "001373", "001374", "001375", "001376", "001377", "001378", "001379", "001380", "001381", "001382", "001383", "001384", "001385", "001386", "001387", "001388", "001389", "001390", "001391", "001392", "001393", "001394", "001395", "001396", "001397", "001398", "001399", "001400", "001401", "001402", "001403", "001404", "001405", "001406", "001407", "001408", "001409", "001410", "001411", "001412", "001413", "001414", "001415", "001416", "001417", "001418", "001419", "001420", "001421", "001422", "001423", "001424", "001425", "001426", "001427", "001428", "001429", "001430", "001431", "001432", "001433", "001434", "001435", "001436", "001437", "001438", "001439", "001440", "001441", "001442", "001443", "001444", "001445", "001446", "001447", "001448", "001449", "001450", "001451", "001452", "001453", "001454", "001455", "001456", "001457", "001458", "001459", "001460", "001461", "001462", "001463", "001464", "001465", "001466", "001467", "001468", "001469", "001470", "001471", "001472", "001473", "001474", "001475", "001476", "001477", "001478", "001479", "001480", "001481", "001482", "001483", "001484", "001485", "001486", "001487", "001488", "001489", "001490", "001491", "001492", "001493", "001494", "001495", "001496", "001497", "001498", "001499", "001500", "001501", "001502", "001503", "001504", "001505", "001506", "001507", "001508", "001509", "001510", "001511", "001512", "001513", "001514", "001515", "001865", "001866", "001867", "001868", "001869", "001870", "001871", "001872", "001873", "001874", "001875", "001876", "001877", "001878", "001879", "001880", "001881", "001882", "001883", "001884", "001885", "001886", "001887", "001888", "001889", "001890", "001891", "001892", "001893", "001894", "001895", "001896", "001897", "001898", "001899", "001900", "001901", "001902", "001903", "001904", "001905", "001906", "001907", "001908", "001909", "001910", "001911", "001912", "001913", "001914", "001915", "001916", "001917", "001918", "001919", "001920", "001921", "001922", "001923", "001924", "001925", "001926", "001927", "001928", "001929", "001930", "001931", "001932", "001933", "001934", "001935", "001936", "001937", "001938", "001939", "001940", "001941", "001942", "001943", "001944", "001945", "001946", "001947", "001948", "001949", "001950", "001951", "001952", "001953", "001954", "001955", "001956", "001957", "001958", "001959", "001960", "001961", "001962", "001963", "001964", "001965", "001966", "001967", "001968", "001969", "001970", "001971", "001972", "001973", "001974", "001975", "001976", "001977", "001978", "001979", "001980", "001981", "001982", "001983", "001984", "001985", "001986", "001987", "001988", "001989", "001990", "001991", "001992", "001993", "001994", "001995", "001996", "001997", "001998", "001999", "002000", "002001", "002002", "002003", "002004", "002005", "002006", "002007", "002008", "002009", "002010", "002011", "002012", "002013", "002014", "002015", "002016", "002017", "002018", "002019", "002020", "002021", "002022", "002023", "002024", "002025", "002026", "002027", "002028", "002029", "002030", "002031", "002032", "002033", "002034", "002035", "002036", "002037", "002038", "002039", "002040", "002041", "002042", "002043", "002044", "002045", "002046", "002047", "002048", "002049", "002050", "002051", "002052", "002053", "002054", "002055", "002056", "002057", "002058", "002059", "002060", "002061", "002062", "002063", "002064", "002244", "002245", "002246", "002247", "002248", "002249", "002250", "002251", "002252", "002253", "002254", "002255", "002256", "002257", "002258", "002259", "002260", "002261", "002262", "002263", "002264", "002265", "002266", "002267", "002268", "002269", "002270", "002271", "002272", "002273", "002274", "002275", "002276", "002277", "002278", "002279", "002280", "002281", "002282", "002283", "002284", "002285", "002286", "002287", "002288", "002289", "002290", "002291", "002292", "002293", "002294", "002295", "002296", "002297", "002298", "002299", "002300", "002301", "002302", "002303", "002304", "002305", "002306", "002307", "002308", "002309", "002310", "002311", "002312", "002313", "002314", "002315", "002316", "002317", "002318", "002319", "002320", "002321", "002322", "002323", "002324", "002325", "002326", "002327", "002328", "002329", "002330", "002331", "002332", "002333", "002334", "002335", "002336", "002337", "002338", "002339", "002340", "002341", "002342", "002343", "002344", "002345", "002346", "002347", "002348", "002349", "002350", "002351", "002352", "002353", "002354", "002355", "002356", "002357", "002358", "002359", "002360", "002361", "002362", "002363", "002364", "002365", "002366", "002367", "002368", "002369", "002370", "002371", "002372", "002373", "002374", "002375", "002376", "002377", "002378", "002379", "002380", "002381", "002382", "003211", "003212", "003213", "003214", "003215", "003216", "003217", "003218", "003219", "003220", "003221", "003222", "003223", "003224", "003225", "003226", "003227", "003228", "003229", "003230", "003231", "003232", "003233", "003234", "003235", "003236", "003237", "003238", "003239", "003240", "003241", "003242", "003243", "003244", "003245", "003246", "003247", "003248", "003249", "003250", "003251", "003252", "003253", "003254", "003255", "003256", "003257", "003258", "003259", "003260", "003261", "003262", "003263", "003264", "003265", "003266", "003267", "003268", "003269", "003270", "003271", "003272", "003273", "003274", "003275", "003276", "003277", "003278", "003279", "003280", "003281", "003282", "003283", "003284", "003285", "003286", "003287", "003288", "003289", "003290", "003291", "003292", "003293", "003294", "003295", "003296", "003297", "003298", "003299", "003300", "003301", "003302", "003303", "003304", "003305", "003306", "003307", "003308", "003309", "003310", "003311", "003312", "003313", "003314", "003315", "003316", "003317", "003318", "003319", "003320", "003321", "003322", "003323", "003324", "003325", "003326", "003327", "003328", "003329", "003330", "003331", "003332", "003333", "003334", "003335", "003336", "003337", "003338", "003339", "003340", "003341", "003342", "003343", "003344", "003345", "003346", "003347", "003348", "003349", "003350", "003351", "003352", "003353", "003354", "003355", "003356", "003357", "003358", "003359", "003360", "003361", "003362", "003363", "003364", "003365", "003366", "003367", "003368", "003369", "003370", "003491", "003492", "003493", "003494", "003495", "003496", "003497", "003498", "003499", "003500", "003501", "003502", "003503", "003504", "003505", "003506", "003507", "003508", "003509", "003510", "003511", "003512", "003513", "003514", "003515", "003516", "003517", "003518", "003519", "003520", "003521", "003522", "003523", "003524", "003525", "003526", "003527", "003528", "003529", "003530", "003531", "003532", "003533", "003534", "003535", "003536", "003537", "003538", "003539", "003540", "003541", "003542", "003543", "003544", "003545", "003546", "003547", "003548", "003549", "003550", "003551", "003552", "003553", "003554", "003555", "003556", "003557", "003558", "003559", "003560", "003561", "003562", "003563", "003564", "003565", "003566", "003567", "003568", "003569", "003570", "003571", "003572", "003573", "003574", "003575", "003576", "003577", "003578", "003579", "003580", "003581", "003582", "003583", "003584", "003585", "003586", "003587", "003588", "003589", "003590", "003591", "003592", "003593", "003594", "003595", "003596", "003597", "003598", "003599", "003600", "003601", "003602", "003603", "003604", "003605", "003606", "003607", "003608", "003609", "003610", "003611", "003612", "003613", "003614", "003615", "003616", "003617", "003618", "003619", "003620", "003621", "003622", "003623", "003624", "003625", "003626", "003627", "003628", "003629", "003630", "003631", "003632", "003633", "003634", "003635", "003636", "003637", "003638", "003639", "003640", "004261", "004262", "004263", "004264", "004265", "004266", "004267", "004268", "004269", "004270", "004271", "004272", "004273", "004274", "004275", "004276", "004277", "004278", "004279", "004280", "004281", "004282", "004283", "004284", "004285", "004286", "004287", "004288", "004289", "004290", "004291", "004292", "004293", "004294", "004295", "004296", "004297", "004298", "004299", "004300", "004301", "004302", "004303", "004304", "004305", "004306", "004307", "004308", "004309", "004310", "004311", "004312", "004313", "004314", "004315", "004316", "004317", "004318", "004319", "004320", "004321", "004322", "004323", "004324", "004325", "004326", "004327", "004328", "004329", "004330", "004331", "004332", "004333", "004334", "004335", "004336", "004337", "004338", "004339", "004340", "004341", "004342", "004343", "004344", "004345", "004346", "004347", "004348", "004349", "004350", "004351", "004352", "004353", "004354", "004355", "004356", "004357", "004358", "004359", "004360", "004361", "004362", "004363", "004364", "004365", "004366", "004367", "004368", "004369", "004370", "004371", "004372", "004373", "004374", "004375", "004376", "004377", "004378", "004379", "004380", "004381", "004382", "004383", "004384", "004385", "004386", "004387", "004388", "004389", "004390", "004391", "004392", "004393", "004394", "004395", "004396", "004397", "004398", "004399", "004400", "004401", "004402", "004403", "004404", "004405", "004406", "004407", "004408", "004409", "004410", "004411", "004412", "004413", "004414", "004415", "004416", "004417", "004418", "004419", "004420", "004421", "004422", "004423", "004424", "004425", "004426", "004427", "004428", "004429", "004430", "004431", "004432", "004433", "004434", "004435", "004436", "004437", "004438", "004439", "004440", "004441", "004442", "004443", "004444", "004445", "004446", "004447", "004448", "004449", "004450", "004451", "004452", "004453", "004454", "004455", "004456", "004457", "004458", "004459", "004460", "004461", "004462", "004463", "004464", "004465", "004466", "004467", "004468", "004469", "004470", "004471", "004472", "004473", "004474", "004475", "004476", "004477", "004478", "004479", "004480", "004481", "004482", "004483", "004484", "004485", "004486", "004487", "004488", "004489", "004490", "004491", "004492", "004493", "004494", "004495", "004496", "004497", "004498", "004499", "004500", "004501", "004502", "004503", "004504", "004505", "004506", "004507", "004508", "004509", "004510", "004511", "004512", "004513", "004514", "004515", "004516", "004517", "004518", "004519", "004520", "004521", "004522", "004523", "004524", "004525", "004526", "004527", "004528", "004529", "004530", "004531", "004532", "004533", "004534", "004535", "004536", "004537", "004538", "004539", "004540", "004541", "004542", "004543", "004544", "004545", "004546", "004547", "004548", "004549", "004550", "004551", "004552", "004553", "004694", "004695", "004696", "004697", "004698", "004699", "004700", "004701", "004702", "004703", "004704", "004705", "004706", "004707", "004708", "004709", "004710", "004711", "004712", "004713", "004714", "004715", "004716", "004717", "004718", "004719", "004720", "004721", "004722", "004723", "004724", "004725", "004726", "004727", "004728", "004729", "004730", "004731", "004732", "004733", "004734", "004735", "004736", "004737", "004738", "004739", "004740", "004741", "004742", "004743", "004744", "004745", "004746", "004747", "004748", "004749", "004750", "004751", "004752", "004753", "004754", "004755", "004756", "004757", "004758", "004759", "004760", "004761", "004762", "004763", "004764", "004765", "004766", "004767", "004768", "004769", "004770", "004771", "004772", "004773", "004774", "004775", "004776", "004777", "004778", "004779", "004780", "004781", "004782", "004783", "004784", "004785", "004786", "004787", "004788", "004789", "004790", "004791", "004792", "004793", "004794", "004795", "004796", "004797", "004798", "004799", "004800", "004801", "004802", "004803", "004804", "004805", "004806", "004807", "004808", "004809", "004810", "004811", "004812", "004813", "004814", "004815", "004816", "004817", "004818", "004819", "004820", "004821", "004822", "004823", "004824", "004825", "004826", "004827", "004828", "004829", "004830", "004831", "004832", "004833", "004834", "004835", "004836", "004837", "004838", "004839", "004840", "004841", "004842", "004843", "004844", "004845", "004846", "004847", "004848", "004849", "004850", "004851", "004852", "004853", "004854", "004855", "004856", "004857", "004858", "004859", "004860", "004861", "004862", "004863", "004864", "004865", "004866", "004867", "004868", "004869", "004870", "004871", "004872", "004873", "004874", "004875", "004876", "004877", "004878", "004879", "004880", "004881", "004882", "004883", "004884", "005414", "005415", "005416", "005417", "005418", "005419", "005420", "005421", "005422", "005423", "005424", "005425", "005426", "005427", "005428", "005429", "005430", "005431", "005432", "005433", "005434", "005435", "005436", "005437", "005438", "005439", "005440", "005441", "005442", "005443", "005444", "005445", "005446", "005447", "005448", "005449", "005450", "005451", "005452", "005453", "005454", "005455", "005456", "005457", "005458", "005459", "005460", "005461", "005462", "005463", "005464", "005465", "005466", "005467", "005468", "005469", "005470", "005471", "005472", "005473", "005474", "005475", "005476", "005477", "005478", "005479", "005480", "005481", "005482", "005483", "005484", "005485", "005486", "005487", "005488", "005489", "005490", "005491", "005492", "005493", "005494", "005495", "005496", "005497", "005498", "005499", "005500", "005501", "005502", "005503", "005504", "005505", "005506", "005507", "005508", "005509", "005510", "005511", "005512", "005513", "005514", "005515", "005516", "005517", "005518", "005519", "005520", "005521", "005522", "005523", "005524", "005525", "005526", "005527", "005528", "005529", "005530", "005531", "005532", "005533", "005534", "005535", "005536", "005537", "005538", "005539", "005540", "005541", "005542", "005543", "005544", "005545", "005546", "005547", "005548", "005549", "005550", "005551", "005552", "005553", "005554", "005555", "005556", "005557", "005558", "005559", "005560", "005561", "005562", "005563", "005564", "005565", "005566", "005567", "005568", "005569", "005570", "005571", "005572", "005573", "005574", "005575", "005576", "005577", "005578", "005579", "005580", "005581", "005582", "005583", "005584", "005585", "005586", "005587", "005588", "005589", "005590", "005591", "005592", "005593", "005594", "005595", "005596", "005597", "005598", "005599", "005600", "005601", "005602", "005603", "005604", "005605", "005606", "005607", "005608", "005609", "005610", "005611", "005612", "005613", "005614", "005615", "005616", "005617", "005618", "005619", "005620", "005621", "005622", "005623", "005624", "005625", "005626", "005627", "005628", "005629", "005630", "005631", "005632", "005633", "005634", "005635", "005636", "005637", "005638", "005639", "005640", "005641", "005642", "005643", "005644", "005645", "005646", "005647", "005648", "005649", "005650", "005651", "005652", "005653", "005654", "005655", "005656", "005657", "005658", "005659", "005660", "005661", "005662", "005663", "005664", "005665", "005666", "005667", "005668", "005669", "005670", "005671", "005672", "005673", "005674", "005675", "005676", "005677", "005678", "005679", "005680", "005681", "005682", "005683", "005684", "005685", "005686", "005687", "005688", "005689", "005690", "005691", "005692", "005693", "005694", "005695", "005696", "005697", "005698", "005699", "005700", "005701", "005702", "005703", "005704", "005705", "005706", "005707", "005708", "005709", "005710", "005711", "005712", "005713", "005714", "005715", "005716", "005717", "005718", "005719", "005720", "005721", "005722", "005723", "005724", "005725", "005726", "005727", "005728", "005729", "005730", "005731", "005732", "005733", "005734", "005735", "005736", "005737", "005738", "005739", "005740", "005741", "005742", "005743", "005917", "005918", "005919", "005920", "005921", "005922", "005923", "005924", "005925", "005926", "005927", "005928", "005929", "005930", "005931", "005932", "005933", "005934", "005935", "005936", "005937", "005938", "005939", "005940", "005941", "005942", "005943", "005944", "005945", "005946", "005947", "005948", "005949", "005950", "005951", "005952", "005953", "005954", "005955", "005956", "005957", "005958", "005959", "005960", "005961", "005962", "005963", "005964", "005965", "005966", "005967", "005968", "005969", "005970", "005971", "005972", "005973", "005974", "005975", "005976", "005977", "005978", "005979", "005980", "005981", "005982", "005983", "005984", "005985", "005986", "005987", "005988", "005989", "005990", "005991", "005992", "005993", "005994", "005995", "005996", "005997", "005998", "005999", "006000", "006001", "006002", "006003", "006004", "006005", "006006", "006007", "006008", "006009", "006010", "006011", "006012", "006013", "006014", "006015", "006016", "006017", "006018", "006019", "006020", "006021", "006022", "006023", "006024", "006025", "006026", "006027", "006028", "006029", "006030", "006031", "006032", "006033", "006034", "006035", "006036", "006037", "006038", "006039", "006040", "006041", "006042", "006043", "006044", "006045", "006046", "006047", "006048", "006049", "006050", "006051", "006052", "006053", "006054", "006055", "006056", "006057", "006058", "006059", "006060", "006061", "006062", "006063", "006064", "006065", "006066", "006067", "006068", "006069", "006070", "006071", "006072", "006073", "006074", "006075", "006076", "006077", "006078", "006079", "006080", "006081", "006082", "006083", "006084", "006085", "006086", "006087", "006088", "006089", "006090", "006091", "006092", "006093", "006094", "006095", "006096", "006097", "006098", "006099", "006100", "006101", "006102", "006103", "006104", "006105", "006106", "006107", "006108", "006109", "006110", "006111", "006112", "006113", "006114", "006115", "006116", "006117", "006118", "006119", "006120", "006121", "006122", "006123", "006124", "006125", "006126", "006127", "006128", "006129", "006130", "006131", "006132", "006133", "006134", "006135", "006136", "006137", "006138", "006139", "006140", "006141", "006142", "006143", "006144", "006145", "006146", "006147", "006148", "006149", "006150", "006151", "006152", "006153", "006154", "006155", "006156", "006157", "006158", "006159", "006160", "006161", "006162", "006163", "006164", "006165", "006166", "006167", "006168", "006169", "006170", "006171", "006172", "006173", "006174", "006175", "006176", "006177", "006178", "006179", "006180", "006181", "006182", "006183", "006184", "006185", "006186", "006187", "006188", "006189", "006190", "006191", "006192", "006193", "006194", "006195", "006196", "006197", "006198", "006199", "006200", "006201", "006202", "006203", "006204", "006205", "006206", "006207", "006208", "006209", "006210", "006211", "006212", "006213", "006214", "006215", "006216", "006217", "006218", "006219", "006220", "006221", "006222", "006223", "006224", "006225", "006226", "006227", "006228", "006229", "006230", "006231", "006232", "006233", "006234", "006235", "006236", "006237", "006238", "006239", "006240", "006241", "006242", "006243", "006244", "006245", "006246", "006247", "006248", "006249", "006250", "006251", "006252", "006253", "006254", "006255", "006256", "006257", "006258", "006259", "006260", "006261", "006262", "006263", "006264", "006265", "006266", "006267", "006268", "006269", "006270", "006271", "006272", "006273", "006274", "006275", "006276", "006277", "006278", "006279", "006280", "006281", "006282", "006283", "006284", "006285", "006286", "006287", "006288", "006289", "006290", "006291", "006292", "006293", "006294", "006295", "006296", "006297", "006298", "006299", "006300", "006301", "006302", "006303", "006304", "006305", "006306", "006307", "006308", "006309", "006310", "006311", "006312", "006313", "006314", "006315", "006316", "006317", "006318", "006319", "006320", "006321", "006322", "006323", "006324", "006325", "006326", "006327", "006328", "006329", "006330", "006331", "006332", "006333", "006334", "006335", "006336", "006337", "006338", "006339", "006340", "006341", "006342", "006343", "006344", "006345", "006346", "006347", "006348", "006349", "006350", "006351", "006352", "006353", "006354", "006355", "006356", "006357", "006358", "006359", "006360", "006361", "006362", "006363", "006364", "006365", "006366", "006367", "006368", "006369", "006370", "006371", "006372", "006373", "006374", "006375", "006376", "006377", "006378", "006379", "006380", "006381", "006382", "006383", "006384", "006385", "006386", "006387", "006388", "006389", "006390", "006391", "006392", "006393", "006394", "006395", "006396", "006397", "006398", "006399", "006400", "006401", "006402", "006403", "006404", "006405", "006406", "006407", "006408", "006409", "006410", "006411", "006412", "006413", "006414", "006415", "006416", "006417", "006418", "006419", "006420", "006421", "006422", "006423", "006424", "006425", "006426", "006427", "006428", "006429", "006430", "006431", "006432", "006433", "006434", "006435", "006436", "006437", "006438", "006439", "006440", "006441", "006442", "006443", "006444", "006445", "006446", "006447", "006448", "006449", "006450", "006451", "006452", "006453", "006454", "006455", "006456", "006457", "006458", "006459", "006460", "006461", "006462", "006463", "006464", "006465", "006466", "006467", "006468", "006469", "006470", "006471", "006472", "006473", "006474", "006475", "006476", "006477", "006478", "006479", "006480", "006481", "006482", "006483", "006484", "006485", "006486", "006487", "006488", "006489", "006490", "006491", "006492", "006493", "006494", "006495", "006496", "006497", "006498", "006499", "006500", "006501", "006502", "006503", "006504", "006505", "006506", "006507", "006508", "006509", "006510", "006511", "006512", "006513", "006514", "006515", "006516", "006517", "006518", "006519", "006520", "006521", "006522", "006523", "006524", "006525", "006526", "006527", "006528", "006529", "006530", "006531", "006532", "006533", "006534", "006535", "006536", "006537", "006538", "006539", "006540", "006541", "006542", "006543", "006544", "006545", "006546", "006547", "006548", "006549", "006550", "006551", "006552", "006553", "006554", "006555", "006556", "006557", "006558", "006559", "006560", "006561", "006562", "006563", "006564", "006565", "006566", "006567", "006568", "006569", "006570", "006571", "006572", "006573", "006574", "006575", "006576", "006577", "006578", "006579", "006580", "006581", "006582", "006583", "006584", "006585", "006586", "006587", "006588", "006589", "006590", "006591", "006592", "006593", "006594", "006595", "006596", "006597", "006598", "006599", "006600", "006601", "006602", "006603", "006604", "006605", "006606", "006607", "006608", "006609", "006610", "006611", "006612", "006613", "006614", "006615", "006616", "006617", "006618", "006619", "006620", "006621", "006622", "006623", "006624", "006625", "006626", "006627", "006628", "006629", "006630", "006631", "006632", "006633", "006634", "006635", "006636", "006637", "006638", "006639", "006640", "006641", "006642", "006643", "006644", "006645", "006646", "006647", "006648", "006649", "006650", "006651", "006652", "006653", "006654", "006655", "006656", "006657", "006658", "006659", "006660", "006661", "006662", "006663", "006664", "006665", "006666", "006667", "006668", "006669", "006670", "006671", "006672", "006673", "006674", "006675", "006676", "006677", "006678", "006679", "006680", "006681", "006682", "006683", "006684", "006685", "006686", "006687", "006688", "006689", "006690", "006691", "006692", "006693", "006694", "006695", "006696", "006697", "006698", "006699", "006700", "006701", "006702", "006703", "006704", "006705", "006706", "006707", "006708", "006709", "006710", "006711", "006712", "006713", "006714", "006715", "006716", "006717", "006718", "006719", "006720", "006721", "006722", "006723", "006724", "006725", "006726", "006727", "006728", "006729", "006730", "006731", "006732", "006733", "006734", "006735", "006736", "006737", "006738", "006739", "006740", "006741", "006742", "006743", "006744", "006745", "006746", "006747", "006748", "006749", "006750", "006751", "006752", "006753", "006754", "006755", "006756", "006757", "006758", "006759", "006760", "006761", "006762", "006763", "006764", "006765", "006766", "006767", "006768", "006769", "006770", "006771", "006772", "006773", "006774", "006775", "006776", "006777", "006778", "006779", "006780", "006781", "006782", "006783", "006784", "006785", "006786", "006787", "006788", "006789", "006790", "006791", "006792", "006793", "006794", "006795", "006796", "006797", "006798", "006799", "006800", "006801", "006802", "006803", "006804", "006805", "006806", "006807", "006808", "006809", "006810", "006811", "006812", "006813", "006814", "006815", "006816", "007256", "007257", "007258", "007259", "007260", "007261", "007262", "007263", "007264", "007265", "007266", "007267", "007268", "007269", "007270", "007271", "007272", "007273", "007274", "007275", "007276", "007277", "007278", "007279", "007280", "007281", "007282", "007283", "007284", "007285", "007286", "007287", "007288", "007289", "007290", "007291", "007292", "007293", "007294", "007295", "007296", "007297", "007298", "007299", "007300", "007301", "007302", "007303", "007304", "007305", "007306", "007307", "007308", "007309", "007310", "007311", "007312", "007313", "007314", "007315", "007316", "007317", "007318", "007319", "007320", "007321", "007322", "007323", "007324", "007325", "007326", "007327", "007328", "007329", "007330", "007331", "007332", "007333", "007334", "007335", "007336", "007337", "007338", "007339", "007340", "007341", "007342", "007343", "007344", "007345", "007346", "007347", "007348", "007349", "007350", "007351", "007352", "007353", "007354", "007355", "007356", "007357", "007358", "007359", "007360", "007361", "007362", "007363", "007364", "007365", "007366", "007367", "007368", "007369", "007370", "007371", "007372", "007373", "007374", "007375", "007376", "007377", "007378", "007379", "007380", "007381", "007382", "007383", "007384", "007385", "007386", "007387", "007388", "007389", "007390", "007391", "007392", "007393", "007394", "007395", "007396", "007397", "007398", "007399", "007400", "007401", "007402", "007403", "007404", "007405", "007406", "007407", "007408", "007409", "007410", "007411", "007412", "007413", "007414", "007415", "007416", "007417", "007418", "007419", "007420", "007421", "007422", "007423", "007424", "007425", "007426", "007427", "007428", "007429", "007430", "007431", "007432", "007433", "007434", "007435", "007436", "007437", "007438", "007439", "007440", "007441", "007442", "007443", "007444", "007445", "007446", "007447", "007448", "007449", "007450", "007451", "007452", "007453", "007454", "007455", "007456", "007457", "007458", "007459", "007460", "007461", "007462", "007463", "007464", "007465", "007466", "007467", "007468", "007469", "007470", "007471", "007472", "007473", "007474", "007475", "007476", "007477", "007478", "007479", "007480", "007481", "007482", "007483", "007484", "007485", "007486", "007487", "007488", "007489", "007490", "007491", "007492", "007493", "007494", "007495", "007496", "007497", "007498", "007499", "007500", "007501", "007502", "007503", "007504", "007505", "007506", "007507", "007508", "007509", "007510", "007511", "007512", "007513", "007514", "007515", "007516", "007517", "007518", "007519", "007520", "007521", "007522", "007523", "007524", "007525", "007526", "007527", "007528", "007529", "007530", "007531", "007532", "007533", "007534", "007535", "007536", "007537", "007538", "007539", "007540", "007541", "007542", "007543", "007544", "007545", "007546", "007547", "007548", "007549", "007550", "007551", "007552", "007553", "007554", "007555", "007556", "007557", "007558", "007559", "007560", "007561", "007562", "007563", "007564", "007565", "007566", "007567", "007568", "007569", "007570", "007571", "007572", "007573", "007574", "007575", "007576", "007577", "007578", "007579", "007580", "007581", "007582", "007583", "007584", "007585", "007586", "007587", "007588", "007589", "007590", "007591", "007592", "007593", "007594", "007595", "007596", "007597", "007598", "007599", "007600", "007601", "007602", "007603", "007604", "007605", "007606", "007607", "007608", "007609", "007610", "007611", "007612", "007613", "007614", "007615", "007616", "007617", "007618", "007619", "007620", "007621", "007622", "007623", "007624", "007625", "008476", "008477", "008478", "008479", "008480", "008481", "008482", "008483", "008484", "008485", "008486", "008487", "008488", "008489", "008490", "008491", "008492", "008493", "008494", "008495", "008496", "008497", "008498", "008499", "008500", "008501", "008502", "008503", "008504", "008505", "008506", "008507", "008508", "008509", "008510", "008511", "008512", "008513", "008514", "008515", "008516", "008517", "008518", "008519", "008520", "008521", "008522", "008523", "008524", "008525", "008526", "008527", "008528", "008529", "008530", "008531", "008532", "008533", "008534", "008535", "008536", "008537", "008538", "008539", "008540", "008541", "008542", "008543", "008544", "008545", "008546", "008547", "008548", "008549", "008550", "008551", "008552", "008553", "008554", "008555", "008556", "008557", "008558", "008559", "008560", "008561", "008562", "008563", "008564", "008565", "008566", "008567", "008568", "008569", "008570", "008571", "008572", "008573", "008574", "008575", "008576", "008577", "008578", "008579", "008580", "008581", "008582", "008583", "008584", "008585", "008586", "008587", "008588", "008589", "008590", "008591", "008592", "008593", "008594", "008595", "008596", "008597", "008598", "008599", "008600", "008601", "008602", "008603", "008604", "008605", "008606", "008607", "008608", "008609", "008610", "008611", "008612", "008613", "008614", "008615", "008616", "008617", "008618", "008619", "008620", "008621", "008622", "008623", "008624", "008625", "008626", "008627", "008628", "008629", "008630", "008631", "008632", "008633", "008634", "008635", "008636", "008637", "008638", "008639", "008640", "008641", "008642", "008643", "008644", "008645", "008646", "008647", "008648", "008649", "008650", "008651", "008652", "008653", "008654", "008655", "008656", "008657", "008658", "008659", "008660", "008661", "008662", "008663", "008664", "008665", "008666", "008667", "008668", "008669", "008670", "008671", "008672", "008673", "008674", "008675", "008676", "008677", "008678", "008679", "008680", "008681", "008682", "008683", "008684", "008685", "008686", "008687", "008688", "008689", "008690", "008691", "008692", "008693", "008694", "008695", "008696", "008697", "008698", "008699", "008700", "008701", "008702", "008703", "008704", "008705", "008706", "008707", "008708", "008709", "008710", "008711", "008712", "008713", "008714", "008715", "008716", "008717", "008718", "008719", "008720", "008721", "008722", "008723", "008724", "008725", "008726", "008727", "008728", "008729", "008730", "008731", "008732", "008733", "008734", "008735", "008736", "008737", "008738", "008739", "008740", "008741", "008742", "008743", "008744", "008745", "008746", "008747", "008748", "008749", "008750", "008751", "008752", "008753", "008754", "008755", "008756", "008757", "008758", "008759", "008760", "008761", "008762", "008763", "008764", "008765", "008766", "008767", "008768", "008769", "008770", "008771", "008772", "008773", "008774", "008775", "008776", "008777", "008778", "008779", "008780", "008781", "008782", "008783", "008784", "008785", "008786", "008787", "008788", "008789", "008790", "008791", "008792", "008793", "008794", "008795", "008796", "008797", "008798", "008799", "008800", "008801", "008802", "008803", "008804", "008805", "008806", "008807", "008808", "008809", "008810", "008811", "008812", "008813", "008814", "008815", "008816", "008817", "008818", "008819", "008820", "008821", "008822", "008823", "008824", "008825", "008826", "008827", "008828", "008829", "008830", "008831", "008832", "008833", "008834", "008835", "008836", "008837", "008838", "008839", "008840", "008841", "008842", "008843", "008844", "008845", "008846", "008847", "008848", "008849", "008850", "008851", "008852", "008853", "008854", "008855", "008856", "008857", "008858", "008859", "008860", "008861", "008862", "008863", "008864", "008865", "008866", "008867", "008868", "008869", "008870", "008871", "008872", "008873", "008874", "008875", "008876", "008877", "008878", "008879", "008880", "008881", "008882", "008883", "008884", "008885", "008886", "008887", "008888", "008889", "008890", "008891", "008892", "008893", "008894", "008895", "008896", "008897", "008898", "008899", "008900", "008901", "008902", "008903", "008904", "008905", "008906", "008907", "008908", "008909", "008910", "008911", "008912", "008913", "008914", "008915", "008916", "008917", "008918", "008919", "008920", "008921", "008922", "008923", "008924", "008925", "008926", "008927", "008928", "008929", "008930", "008931", "008932", "008933", "008934", "008935", "008936", "008937", "008938", "008939", "008940", "008941", "008942", "008943", "008944", "008945", "008946", "008947", "008948", "008949", "008950", "008951", "008952", "008953", "008954", "008955", "008956", "008957", "008958", "008959", "008960", "008961", "008962", "008963", "008964", "008965", "008966", "008967", "008968", "008969", "008970", "008971", "008972", "008973", "008974", "008975", "008976", "008977", "008978", "008979", "008980", "008981", "008982", "008983", "008984", "008985", "008986", "008987", "008988", "008989", "008990", "008991", "008992", "008993", "008994", "008995", "008996", "008997", "008998", "008999", "009000", "009001", "009002", "009003", "009004", "009005", "009006", "009007", "009008", "009009", "009010", "009011", "009012", "009013", "009014", "009015", "009016", "009017", "009018", "009019", "009020", "009021", "009022", "009023", "009024", "009025", "009026", "009027", "009028", "009029", "009030", "009031", "009032", "009033", "009034", "009035", "009036", "009037", "009038", "009039", "009040", "009041", "009042", "009043", "009044", "009045", "009046", "009047", "009048", "009049", "009050", "009051", "009052", "009053", "009054", "009055", "009056", "009057", "009058", "009059", "009060", "009061", "009062", "009063", "009064", "009065", "009066", "009067", "009068", "009069", "009070", "009071", "009072", "009073", "009074", "009075", "009076", "009077", "009078", "009079", "009080", "009081", "009082", "009083", "009084", "009085", "009086", "009087", "009088", "009089", "009090", "009091", "009092", "009093", "009094", "009095", "009096", "009097", "009098", "009099", "009100", "009101", "009102", "009103", "009104", "009105", "009106", "009107", "009108", "009109", "009110", "009111", "009112", "009113", "009114", "009115", "009116", "009117", "009118", "009119", "009120", "009121", "009122", "009123", "009124", "009125", "009126", "009127", "009128", "009129", "009130", "009131", "009132", "009133", "009134", "009135", "009136", "009137", "009138", "009139", "009140", "009141", "009142", "009143", "009144", "009145", "009146", "009147", "009148", "009149", "009150", "009691", "009692", "009693", "009694", "009695", "009696", "009697", "009698", "009699", "009700", "009701", "009702", "009703", "009704", "009705", "009706", "009707", "009708", "009709", "009710", "009711", "009712", "009713", "009714", "009715", "009716", "009717", "009718", "009719", "009720", "009721", "009722", "009723", "009724", "009725", "009726", "009727", "009728", "009729", "009730", "009731", "009732", "009733", "009734", "009735", "009736", "009737", "009738", "009739", "009740", "009741", "009742", "009743", "009744", "009745", "009746", "009747", "009748", "009749", "009750", "009751", "009752", "009753", "009754", "009755", "009756", "009757", "009758", "009759", "009760", "009761", "009762", "009763", "009764", "009765", "009766", "009767", "009768", "009769", "009770", "009771", "009772", "009773", "009774", "009775", "009776", "009777", "009778", "009779", "009780", "009781", "009782", "009783", "009784", "009785", "009786", "009787", "009788", "009789", "009790", "009791", "009792", "009793", "009794", "009795", "009796", "009797", "009798", "009799", "009800", "009801", "009802", "009803", "009804", "009805", "009806", "009807", "009808", "009809", "009810", "009811", "009812", "009813", "009814", "009815", "009816", "009817", "009818", "009819", "009820", "009821", "009822", "009823", "009824", "009825", "009826", "009827", "009828", "009829", "009830", "009831", "009832", "009833", "009834", "009835", "009836", "009837", "009838", "009839", "009840", "009841", "009842", "009843", "009844", "009845", "009846", "009847", "009848", "009849", "009850", "009851", "009852", "009853", "009854", "009855", "009856", "009857", "009858", "009859", "009860", "009861", "009862", "009863", "009864", "009865", "009866", "009867", "009868", "009869", "009870", "009871", "009872", "009873", "009874", "009875", "009876", "009877", "009878", "009879", "009880", "009881", "009882", "009883", "009884", "009885", "009886", "009887", "009888", "009889", "009890", "009891", "009892", "009893", "009894", "009895", "009896", "009897", "009898", "009899", "009900", "009901", "009902", "009903", "009904", "009905", "009906", "009907", "009908", "009909", "009910", "009911", "009912", "009913", "009914", "009915", "009916", "009917", "009918", "009919", "009920", "009921", "009922", "009923", "009924", "009925", "009926", "009927", "009928", "009929", "009930", "009931", "009932", "009933", "009934", "009935", "009936", "009937", "009938", "009939", "009940", "009941", "009942", "009943", "009944", "009945", "009946", "009947", "009948", "009949", "009950", "009951", "009952", "009953", "009954", "009955", "009956", "009957", "009958", "009959", "009960", "009961", "009962", "009963", "009964", "009965", "009966", "009967", "009968", "009969", "009970", "009971", "009972", "009973", "009974", "009975", "009976", "009977", "009978", "009979", "009980", "009981", "009982", "009983", "009984", "009985", "009986", "009987", "009988", "009989", "009990", "009991", "009992", "009993", "009994", "009995", "009996", "009997", "009998", "009999", "010000", "010001", "010002", "010003", "010004", "010005", "010006", "010007", "010008", "010009", "010010", "010011", "010012", "010013", "010014", "010015", "010016", "010017", "010018", "010019", "010020", "010021", "010022", "010023", "010024", "010025", "010026", "010027", "010028", "010029", "010030", "010031", "010032", "010033", "010034", "010035", "010036", "010037", "010038", "010039", "010040", "010041", "010042", "010043", "010044", "010045", "010046", "010047", "010048", "010049", "010050", "010051", "010052", "010053", "010054", "010055", "010056", "010057", "010058", "010059", "010060", "010061", "010062", "010063", "010064", "010065", "010066", "010067", "010068", "010069", "010070", "010071", "010072", "010073", "010074", "010075", "010076", "010077", "010078", "010079", "010080", "010081", "010082", "010083", "010084", "010085", "010086", "010087", "010088", "010089", "010090", "010091", "010092", "010093", "010094", "010095", "010096", "010097", "010098", "010099", "010100", "010101", "010102", "010103", "010104", "010105", "010106", "010107", "010108", "010109", "010110", "010111", "010112", "010113", "010114", "010115", "010116", "010117", "010118", "010119", "010120", "010121", "010122", "010123", "010124", "010125", "010126", "010127", "010128", "010129", "010130", "010131", "010132", "010133", "010134", "010135", "010136", "010137", "010138", "010139", "010140", "010141", "010142", "010143", "010144", "010145", "010146", "010147", "010148", "010149", "010150", "010151", "010152", "010153", "010154", "010155", "010156", "010157", "010158", "010159", "010160", "010161", "010162", "010163", "010164", "010165", "010166", "010167", "010168", "010169", "010170", "010171", "010172", "010173", "010174", "010175", "010176", "010177", "010178", "010179", "010180", "010181", "010182", "010183", "010184", "010185", "010186", "010187", "010188", "010189", "010190", "010191", "010192", "010193", "010194", "010195", "010196", "010197", "010198", "010199", "010200", "010201", "010202", "010203", "010204", "010205", "010206", "010207", "010208", "010209", "010210", "010211", "010212", "010213", "010214", "010215", "010216", "010217", "010218", "010219", "010220", "010221", "010222", "010223", "010224", "010225", "010226", "010227", "010228", "010229", "010230", "010231", "010232", "010233", "010234", "010235", "010236", "010237", "010238", "010239", "010240", "010241", "010242", "010243", "010244", "010245", "010246", "010247", "010248", "010249", "010250", "010251", "010252", "010253", "010254", "010255", "010256", "010257", "010258", "010259", "010260", "010261", "010262", "010263", "010264", "010265", "010266", "010267", "010268", "010269", "010270", "010271", "010272", "010273", "010274", "010275", "010276", "010277", "010278", "010279", "010280", "010281", "010282", "010283", "010284", "010285", "010286", "010287", "010288", "010289", "010290", "010291", "010292", "010293", "010294", "010295", "010296", "010297", "010298", "010299", "010300", "010301", "010302", "010303", "010304", "010305", "010306", "010307", "010308", "010309", "010310", "010311", "010312", "010313", "010314", "010315", "010316", "010317", "010318", "010319", "010320", "010321", "010322", "010323", "010324", "010325", "010326", "010327", "010328", "010329", "010330", "010331", "010332", "010333", "010334", "010335", "010336", "010337", "010338", "010339", "010340", "010341", "010342", "010343", "010344", "010345", "010346", "010347", "010348", "010349", "010350", "010351", "010352", "010353", "010354", "010355", "010356", "010357", "010358", "010359", "010360", "010361", "010362", "010363", "010364", "010365", "010366", "010367", "010368", "010369", "010370", "010371", "010372", "010373", "010374", "010375", "010376", "010377", "010378", "010379", "010380", "010381", "010382", "010383", "010384", "010385", "010386", "010387", "010388", "010389", "010390", "010391", "010392", "010393", "010394", "010395", "010396", "010397", "010398", "010399", "010400", "010401", "010402", "010403", "010404", "010405", "010406", "010407", "010408", "010409", "010410", "010411", "010412", "010413", "010414", "010415", "010416", "010417", "010418", "010419", "010420", "010421", "010422", "010423", "010424", "010425", "010426", "010427", "010428", "010429", "010430", "010431", "010432", "010433", "010434", "010435", "010436", "010437", "010438", "010439", "010440", "010441", "010442", "010443", "010444", "010445", "010446", "010447", "010448", "010449", "010450", "010451", "010452", "010453", "010454", "010455", "010456", "010457", "010458", "010459", "010460", "010461", "010462", "010463", "010464", "010465", "010466", "010467", "010468", "010469", "010470", "010471", "010472", "010473", "010474", "010475", "010476", "010477", "010478", "010479", "010480", "010941", "010942", "010943", "010944", "010945", "010946", "010947", "010948", "010949", "010950", "010951", "010952", "010953", "010954", "010955", "010956", "010957", "010958", "010959", "010960", "010961", "010962", "010963", "010964", "010965", "010966", "010967", "010968", "010969", "010970", "010971", "010972", "010973", "010974", "010975", "010976", "010977", "010978", "010979", "010980", "010981", "010982", "010983", "010984", "010985", "010986", "010987", "010988", "010989", "010990", "010991", "010992", "010993", "010994", "010995", "010996", "010997", "010998", "010999", "011000", "011001", "011002", "011003", "011004", "011005", "011006", "011007", "011008", "011009", "011010", "011011", "011012", "011013", "011014", "011015", "011016", "011017", "011018", "011019", "011020", "011021", "011022", "011023", "011024", "011025", "011026", "011027", "011028", "011029", "011030", "011031", "011032", "011033", "011034", "011035", "011036", "011037", "011038", "011039", "011040", "011041", "011042", "011043", "011044", "011045", "011046", "011047", "011048", "011049", "011050", "011051", "011052", "011053", "011054", "011055", "011056", "011057", "011058", "011059", "011060", "011061", "011062", "011063", "011064", "011065", "011066", "011067", "011068", "011069", "011070", "011071", "011072", "011073", "011074", "011075", "011076", "011077", "011078", "011079", "011080", "011081", "011082", "011083", "011084", "011085", "011086", "011087", "011088", "011089", "011090", "011091", "011092", "011093", "011094", "011095", "011096", "011097", "011098", "011099", "011100", "011101", "011102", "011103", "011104", "011105", "011106", "011107", "011108", "011109", "011110", "011111", "011112", "011113", "011114", "011115", "011116", "011117", "011118", "011119", "011120", "011121", "011122", "011123", "011124", "011125", "011126", "011127", "011128", "011129", "011130", "011131", "011132", "011133", "011134", "011135", "011136", "011137", "011138", "011139", "011140", "011141", "011142", "011143", "011144", "011145", "011146", "011147", "011148", "011149", "011150", "011261", "011262", "011263", "011264", "011265", "011266", "011267", "011268", "011269", "011270", "011271", "011272", "011273", "011274", "011275", "011276", "011277", "011278", "011279", "011280", "011281", "011282", "011283", "011284", "011285", "011286", "011287", "011288", "011289", "011290", "011291", "011292", "011293", "011294", "011295", "011296", "011297", "011298", "011299", "011300", "011301", "011302", "011303", "011304", "011305", "011306", "011307", "011308", "011309", "011310", "011311", "011312", "011313", "011314", "011315", "011316", "011317", "011318", "011319", "011320", "011321", "011322", "011323", "011324", "011325", "011326", "011327", "011328", "011329", "011330", "011331", "011332", "011333", "011334", "011335", "011336", "011337", "011338", "011339", "011340", "011341", "011342", "011343", "011344", "011345", "011346", "011347", "011348", "011349", "011350", "011351", "011352", "011353", "011354", "011355", "011356", "011357", "011358", "011359", "011360", "011361", "011362", "011363", "011364", "011365", "011366", "011367", "011368", "011369", "011370", "011371", "011372", "011373", "011374", "011375", "011376", "011377", "011378", "011379", "011380", "011381", "011382", "011383", "011384", "011385", "011386", "011387", "011388", "011389", "011390", "011391", "011392", "011393", "011394", "011395", "011396", "011397", "011398", "011399", "011400", "011401", "011402", "011403", "011404", "011405", "011406", "011407", "011408", "011409", "011410", "011411", "011412", "011413", "011414", "011415", "011416", "011417", "011418", "011419", "011420", "011421", "011422", "011423", "011424", "011425", "011426", "011427", "011428", "011429", "011430", "011431", "011432", "011433", "011434", "011435", "011436", "011437", "011438", "011439", "011440", "011441", "011442", "011443", "011444", "011445", "011446", "011447", "011448", "011449", "011450", "012091", "012092", "012093", "012094", "012095", "012096", "012097", "012098", "012099", "012100", "012101", "012102", "012103", "012104", "012105", "012106", "012107", "012108", "012109", "012110", "012111", "012112", "012113", "012114", "012115", "012116", "012117", "012118", "012119", "012120", "012121", "012122", "012123", "012124", "012125", "012126", "012127", "012128", "012129", "012130", "012131", "012132", "012133", "012134", "012135", "012136", "012137", "012138", "012139", "012140", "012141", "012142", "012143", "012144", "012145", "012146", "012147", "012148", "012149", "012150", "012151", "012152", "012153", "012154", "012155", "012156", "012157", "012158", "012159", "012160", "012161", "012162", "012163", "012164", "012165", "012166", "012167", "012168", "012169", "012170", "012171", "012172", "012173", "012174", "012175", "012176", "012177", "012178", "012179", "012180", "012181", "012182", "012183", "012184", "012185", "012186", "012187", "012188", "012189", "012190", "012191", "012192", "012193", "012194", "012195", "012196", "012197", "012198", "012199", "012200", "012201", "012202", "012203", "012204", "012205", "012206", "012207", "012208", "012209", "012210", "012211", "012212", "012213", "012214", "012215", "012216", "012217", "012218", "012219", "012220", "012221", "012222", "012223", "012224", "012225", "012226", "012227", "012228", "012229", "012230", "012231", "012232", "012233", "012234", "012235", "012236", "012237", "012238", "012239", "012240", "012241", "012242", "012243", "012244", "012245", "012246", "012247", "012248", "012249", "012250", "012251", "012252", "012253", "012254", "012255", "012256", "012257", "012258", "012259", "012260", "012261", "012262", "012263", "012264", "012265", "012266", "012267", "012268", "012269", "012270", "012271", "012272", "012273", "012274", "012275", "012276", "012277", "012278", "012279", "012280", "012281", "012282", "012283", "012284", "012285", "012286", "012287", "012288", "012289", "012290", "012511", "012512", "012513", "012514", "012515", "012516", "012517", "012518", "012519", "012520", "012521", "012522", "012523", "012524", "012525", "012526", "012527", "012528", "012529", "012530", "012531", "012532", "012533", "012534", "012535", "012536", "012537", "012538", "012539", "012540", "012541", "012542", "012543", "012544", "012545", "012546", "012547", "012548", "012549", "012550", "012551", "012552", "012553", "012554", "012555", "012556", "012557", "012558", "012559", "012560", "012561", "012562", "012563", "012564", "012565", "012566", "012567", "012568", "012569", "012570", "012571", "012572", "012573", "012574", "012575", "012576", "012577", "012578", "012579", "012580", "012581", "012582", "012583", "012584", "012585", "012586", "012587", "012588", "012589", "012590", "012591", "012592", "012593", "012594", "012595", "012596", "012597", "012598", "012599", "012600", "012601", "012602", "012603", "012604", "012605", "012606", "012607", "012608", "012609", "012610", "012611", "012612", "012613", "012614", "012615", "012616", "012617", "012618", "012619", "012620", "012621", "012622", "012623", "012624", "012625", "012626", "012627", "012628", "012629", "012630", "012631", "012632", "012633", "012634", "012635", "012636", "012637", "012638", "012639", "012640", "012641", "012642", "012643", "012644", "012645", "012646", "012647", "012648", "012649", "012650", "012651", "012652", "012653", "012654", "012655", "012656", "012657", "012658", "012659", "012660", "012661", "012662", "012663", "012664", "012665", "012666", "012667", "012668", "012669", "012670", "012671", "012672", "012673", "012674", "012675", "012676", "012677", "012678", "012679", "012680", "012681", "012682", "012683", "012684", "012685", "012686", "012687", "012688", "012689", "012690", "012691", "012692", "012693", "012694", "012695", "012696", "012697", "012698", "012699", "012700", "012701", "012702", "012703", "012704", "012705", "012706", "012707", "012708", "012709", "012710", "012711", "012712", "012713", "012714", "012715", "012716", "012717", "012718", "012719", "012720", "012721", "012722", "012723", "012724", "012725", "012726", "012727", "012728", "012729", "012730", "012731", "012732", "012733", "012734", "012735", "012736", "012737", "012738", "012739", "012740", "012741", "012742", "012743", "012744", "012745", "012746", "012747", "012748", "012749", "012750", "012751", "012752", "012753", "012754", "012755", "012756", "012757", "012758", "012759", "012760", "012761", "012762", "012763", "012764", "012765", "012766", "012767", "012768", "012769", "012770", "012771", "012772", "012773", "012774", "012775", "012776", "012777", "012778", "012779", "012780", "012781", "012782", "012783", "012784", "012785", "012786", "012787", "012788", "012789", "012790", "012791", "012792", "012793", "012794", "012795", "012796", "012797", "012798", "012799", "012800", "012801", "012802", "012803", "012804", "012805", "012806", "012807", "012808", "012809", "012810", "013001", "013002", "013003", "013004", "013005", "013006", "013007", "013008", "013009", "013010", "013011", "013012", "013013", "013014", "013015", "013016", "013017", "013018", "013019", "013020", "013021", "013022", "013023", "013024", "013025", "013026", "013027", "013028", "013029", "013030", "013031", "013032", "013033", "013034", "013035", "013036", "013037", "013038", "013039", "013040", "013041", "013042", "013043", "013044", "013045", "013046", "013047", "013048", "013049", "013050", "013051", "013052", "013053", "013054", "013055", "013056", "013057", "013058", "013059", "013060", "013061", "013062", "013063", "013064", "013065", "013066", "013067", "013068", "013069", "013070", "013071", "013072", "013073", "013074", "013075", "013076", "013077", "013078", "013079", "013080", "013081", "013082", "013083", "013084", "013085", "013086", "013087", "013088", "013089", "013090", "013091", "013092", "013093", "013094", "013095", "013096", "013097", "013098", "013099", "013100", "013101", "013102", "013103", "013104", "013105", "013106", "013107", "013108", "013109", "013110", "013111", "013112", "013113", "013114", "013115", "013116", "013117", "013118", "013119", "013120", "013121", "013122", "013123", "013124", "013125", "013126", "013127", "013128", "013129", "013130", "013131", "013132", "013133", "013134", "013135", "013136", "013137", "013138", "013139", "013140", "013141", "013142", "013143", "013144", "013145", "013146", "013147", "013148", "013149", "013150", "013151", "013152", "013153", "013154", "013155", "013156", "013157", "013158", "013159", "013160", "013161", "013162", "013163", "013164", "013165", "013166", "013167", "013168", "013169", "013170", "013171", "013172", "013173", "013174", "013175", "013176", "013177", "013178", "013179", "013180", "013181", "013182", "013183", "013184", "013185", "013186", "013187", "013188", "013189", "013190", "013191", "013192", "013193", "013194", "013195", "013196", "013197", "013198", "013199", "013200", "013201", "013202", "013203", "013204", "013205", "013206", "013207", "013208", "013209", "013420", "013421", "013422", "013423", "013424", "013425", "013426", "013427", "013428", "013429", "013430", "013431", "013432", "013433", "013434", "013435", "013436", "013437", "013438", "013439", "013440", "013441", "013442", "013443", "013444", "013445", "013446", "013447", "013448", "013449", "013450", "013451", "013452", "013453", "013454", "013455", "013456", "013457", "013458", "013459", "013460", "013461", "013462", "013463", "013464", "013465", "013466", "013467", "013468", "013469", "013470", "013471", "013472", "013473", "013474", "013475", "013476", "013477", "013478", "013479", "013480", "013481", "013482", "013483", "013484", "013485", "013486", "013487", "013488", "013489", "013490", "013491", "013492", "013493", "013494", "013495", "013496", "013497", "013498", "013499", "013500", "013501", "013502", "013503", "013504", "013505", "013506", "013507", "013508", "013509", "013510", "013511", "013512", "013513", "013514", "013515", "013516", "013517", "013518", "013519", "013520", "013521", "013522", "013523", "013524", "013525", "013526", "013527", "013528", "013529", "013530", "013531", "013532", "013533", "013534", "013535", "013536", "013537", "013538", "013539", "013540", "013541", "013542", "013543", "013544", "013545", "013546", "013547", "013548", "013549", "013550", "013551", "013552", "013553", "013554", "013555", "013556", "013557", "013558", "013559", "013560", "013561", "013562", "013563", "013564", "013565", "013566", "013567", "013568", "013569", "013570", "013571", "013572", "013573", "013574", "013575", "013576", "013577", "013578", "013579", "013580", "013581", "013582", "013583", "013584", "013585", "013586", "013587", "013588", "013589", "013590", "013591", "013592", "013593", "013594", "013595", "013596", "013597", "013598", "013599", "013600", "013601", "013602", "013603", "013604", "013605", "013606", "013607", "013608", "013609", "013610", "013611", "013612", "013613", "013614", "013615", "013616", "013617", "013618", "013619", "013620", "013621", "013622", "013623", "013624", "013625", "013626", "013627", "013628", "013629", "013630", "013631", "013632", "013633", "013634", "013635", "013636", "013637", "013638", "013639", "013640", "013641", "013642", "013643", "013644", "013645", "013646", "013647", "013648", "013649", "013650", "013651", "013652", "013653", "013654", "013655", "013656", "013657", "013658", "013659", "013660", "013661", "013662", "013663", "013664", "013665", "013666", "013667", "013668", "013669", "013670", "013671", "013672", "013673", "013674", "013675", "013676", "013677", "013678", "013679", "013680", "013681", "013682", "013683", "013684", "013685", "013686", "013687", "013688", "013689", "013690", "013691", "013692", "013693", "013694", "013695", "013696", "013697", "013698", "013699", "014158", "014159", "014160", "014161", "014162", "014163", "014164", "014165", "014166", "014167", "014168", "014169", "014170", "014171", "014172", "014173", "014174", "014175", "014176", "014177", "014178", "014179", "014180", "014181", "014182", "014183", "014184", "014185", "014186", "014187", "014188", "014189", "014190", "014191", "014192", "014193", "014194", "014195", "014196", "014197", "014198", "014199", "014200", "014201", "014202", "014203", "014204", "014205", "014206", "014207", "014208", "014209", "014210", "014211", "014212", "014213", "014214", "014215", "014216", "014217", "014218", "014219", "014220", "014221", "014222", "014223", "014224", "014225", "014226", "014227", "014228", "014229", "014230", "014231", "014232", "014233", "014234", "014235", "014236", "014237", "014238", "014239", "014240", "014241", "014242", "014243", "014244", "014245", "014246", "014247", "014248", "014249", "014250", "014251", "014252", "014253", "014254", "014255", "014256", "014257", "014258", "014259", "014260", "014261", "014262", "014263", "014264", "014265", "014266", "014267", "014268", "014269", "014270", "014271", "014272", "014273", "014274", "014275", "014276", "014277", "014278", "014279", "014280", "014281", "014282", "014283", "014284", "014285", "014286", "014287", "014288", "014289", "014290", "014291", "014292", "014293", "014294", "014295", "014296", "014297", "014298", "014299", "014300", "014301", "014302", "014303", "014304", "014305", "014306", "014307", "014308", "014309", "014310", "014311", "014312", "014313", "014314", "014315", "014316", "014317", "014318", "014319", "014320", "014321", "014322", "014323", "014324", "014325", "014326", "014327", "014328", "014329", "014330", "014331", "014332", "014333", "014334", "014335", "014336", "014337", "014338", "014339", "014340", "014341", "014342", "014343", "014344", "014345", "014346", "014347", "014348", "014349", "014350", "014351", "014352", "014353", "014354", "014355", "014356", "014357", "014358", "014359", "014360", "014361", "014362", "014363", "014364", "014365", "014366", "014367", "014368", "014369", "014370", "014371", "014372", "014373", "014374", "014375", "014376", "014377", "014378", "014379", "014380", "014381", "014382", "014383", "014384", "014385", "014386", "014387", "014388", "014389", "014390", "014391", "014392", "014393", "014394", "014395", "014396", "014397", "014398", "014399", "014400", "014401", "014402", "014403", "014404", "014405", "014406", "014407", "014408", "014409", "014410", "014411", "014412", "014413", "014414", "014415", "014416", "014417", "014418", "014419", "014420", "014421", "014422", "014423", "014424", "014425", "014426", "014427", "014428", "014429", "014430", "014431", "014432", "014433", "014434", "014435", "014436", "014437", "014438", "014439", "014440", "014441", "014442", "014443", "014444", "014445", "014446", "014447", "014448", "014449", "014450", "014451", "014452", "014453", "014454", "014455", "014456", "014457", "014458", "014459", "014460", "014461", "014462", "014463", "014464", "014465", "014466", "014467", "014468", "014469", "014470", "014471", "014472", "014473", "014474", "014475", "014476", "014477", "014478", "014479", "014480", "014481", "014482", "014483", "014484", "014485", "014486", "014487", "014488", "014489", "014490", "014491", "014492", "014493", "014494", "014495", "014496", "014497", "014498", "014499", "014500", "014501", "014502", "014503", "014504", "014505", "014506", "014507", "014508", "014509", "014510", "014511", "014512", "014513", "014514", "014515", "014516", "014517", "014518", "014519", "014520", "014521", "014522", "014523", "014524", "014525", "014526", "014527", "014528", "014529", "014530", "014531", "014532", "014533", "014534", "014535", "014536", "014537", "014538", "014539", "014540", "014541", "014542", "014543", "014544", "014545", "014546", "014547", "014548", "014549", "014550", "014551", "014552", "014553", "014554", "014555", "014556", "014557", "014558", "014559", "014560", "014561", "014562", "014563", "014564", "014565", "014566", "014567", "014568", "014569", "014570", "014571", "014572", "014573", "014574", "014575", "014576", "014577", "014578", "014579", "014580", "014581", "014582", "014583", "014584", "014585", "014586", "014587", "014588", "014589", "014590", "014591", "014592", "014593", "014594", "014595", "014596", "014597", "014598", "014599", "014600", "014601", "014602", "014603", "014604", "014605", "014606", "014607", "014608", "014609", "014610", "014611", "014612", "014613", "014614", "014615", "014616", "014617", "014618", "014619", "014620", "014621", "014622", "014623", "014624", "014625", "014626", "014627", "014628", "014629", "014630", "014631", "014632", "014633", "014634", "014635", "014636", "014637", "014638", "014639", "014640", "014641", "014642", "014643", "014644", "014645", "014646", "014647", "014648", "014649", "014650", "014651", "014652", "014653", "014654", "014655", "014656", "014657", "014658", "014659", "014660", "014661", "014662", "014663", "014664", "014665", "014666", "014667", "014668", "014669", "014670", "014671", "014672", "014673", "014674", "014675", "014676", "014677", "014678", "014679", "014680", "014681", "014682", "014683", "014684", "014685", "014686", "014687", "014688", "014689", "014690", "014691", "014692", "014693", "014694", "014695", "014696", "014697", "014698", "014699", "014700", "014701", "014702", "014703", "014704", "014705", "014706", "014707", "014708", "014709", "014710", "014711", "014712", "014713", "014714", "014715", "014716", "014717", "014718", "014719", "014720", "014721", "014722", "014723", "014724", "014725", "014726", "014727", "014728", "014729", "014730", "014731", "014732", "014733", "014734", "014735", "014736", "014737", "014738", "014739", "014740", "014741", "014742", "014743", "014744", "014745", "014746", "014747", "014748", "014749", "014750", "014751", "014752", "014753", "014754", "014755", "014756", "014757", "014758", "014759", "014760", "014761", "014762", "014763", "014764", "014765", "014766", "014767", "014768", "014769", "014770", "014771", "014772", "014773", "014774", "014775", "014776", "014777", "014778", "014779", "014780", "014781", "014782", "014783", "014784", "014785", "014786", "014787", "014788", "014789", "014790", "014791", "014792", "014793", "014794", "014795", "014796", "014797", "014798", "014799", "014800", "014801", "014802", "014803", "014804", "014805", "014806", "014807", "014808", "014809", "014810", "014811", "014812", "014813", "014814", "014815", "014816", "014817", "014818", "014819", "014820", "014821", "014822", "014823", "014824", "014825", "014826", "014827", "014828", "014829", "014830", "014831", "014832", "014833", "014834", "014835", "014836", "014837", "014838", "014839", "014840", "014841", "014842", "014843", "014844", "014845", "014846", "014847", "014848", "014849", "014850", "014851", "014852", "014853", "014854", "014855", "014856", "014857", "014858", "014859", "014860", "014861", "014862", "014863", "014864", "014865", "014866", "014867", "014868", "014869", "014870", "014871", "014872", "014873", "014874", "014875", "014876", "014877", "014878", "014879", "014880", "014881", "014882", "014883", "014884", "014885", "014886", "014887", "014888", "014889", "014890", "014891", "014892", "014893", "014894", "014895", "014896", "014897", "014898", "014899", "014900", "014901", "014902", "014903", "014904", "014905", "014906", "014907", "014908", "014909", "014910", "014911", "014912", "014913", "014914", "014915", "014916", "014917", "014918", "014919", "014920", "014921", "014922", "014923", "014924", "014925", "014926", "014927", "014928", "014929", "014930", "014931", "014932", "014933", "014934", "014935", "014936", "014937", "014938", "014939", "014940", "014941", "014942", "014943", "014944", "014945", "014946", "014947", "014948", "014949", "014950", "014951", "014952", "014953", "014954", "014955", "014956", "014957", "014958", "014959", "014960", "014961", "014962", "014963", "014964", "014965", "014966", "014967", "014968", "014969", "014970", "014971", "014972", "014973", "014974", "014975", "014976", "014977", "014978", "014979", "014980", "014981", "014982", "014983", "014984", "014985", "014986", "014987", "014988", "014989", "014990", "014991", "014992", "014993", "014994", "014995", "014996", "014997", "014998", "014999", "015000", "015001", "015002", "015003", "015004", "015005", "015006", "015007", "015008", "015009", "015010", "015011", "015012", "015013", "015014", "015015", "015016", "015017", "015018", "015019", "015020", "015021", "015022", "015023", "015024", "015025", "015026", "015027", "015028", "015029", "015030", "015031", "015032", "015033", "015034", "015035", "015036", "015037", "015038", "015039", "015040", "015041", "015042", "015043", "015044", "015045", "015046", "015047", "015048", "015049", "015050", "015051", "015052", "015053", "015054", "015055", "015056", "015057", "015058", "015059", "015060", "015061", "015062", "015063", "015064", "015065", "015066", "015067", "015068", "015069", "015070", "015071", "015072", "015073", "015074", "015075", "015076", "015077", "015078", "015079", "015080", "015081", "015082", "015083", "015084", "015085", "015086", "015087", "015088", "015089", "015090", "015091", "015092", "015093", "015094", "015095", "015096", "015097", "015098", "015099", "015100", "015101", "015102", "015103", "015104", "015105", "015106", "015107", "015108", "015109", "015110", "015111", "015112", "015113", "015114", "015115", "015116", "015117", "015118", "015119", "015120", "015121", "015122", "015123", "015124", "015125", "015126", "015127", "015128", "015129", "015130", "015131", "015132", "015133", "015134", "015135", "015136", "015137", "015298", "015299", "015300", "015301", "015302", "015303", "015304", "015305", "015306", "015307", "015308", "015309", "015310", "015311", "015312", "015313", "015314", "015315", "015316", "015317", "015318", "015319", "015320", "015321", "015322", "015323", "015324", "015325", "015326", "015327", "015328", "015329", "015330", "015331", "015332", "015333", "015334", "015335", "015336", "015337", "015338", "015339", "015340", "015341", "015342", "015343", "015344", "015345", "015346", "015347", "015348", "015349", "015350", "015351", "015352", "015353", "015354", "015355", "015356", "015357", "015358", "015359", "015360", "015361", "015362", "015363", "015364", "015365", "015366", "015367", "015368", "015369", "015370", "015371", "015372", "015373", "015374", "015375", "015376", "015377", "015378", "015379", "015380", "015381", "015382", "015383", "015384", "015385", "015386", "015387", "015388", "015389", "015390", "015391", "015392", "015393", "015394", "015395", "015396", "015397", "015398", "015399", "015400", "015401", "015402", "015403", "015404", "015405", "015406", "015407", "015768", "015769", "015770", "015771", "015772", "015773", "015774", "015775", "015776", "015777", "015778", "015779", "015780", "015781", "015782", "015783", "015784", "015785", "015786", "015787", "015788", "015789", "015790", "015791", "015792", "015793", "015794", "015795", "015796", "015797", "015798", "015799", "015800", "015801", "015802", "015803", "015804", "015805", "015806", "015807", "015808", "015809", "015810", "015811", "015812", "015813", "015814", "015815", "015816", "015817", "015818", "015819", "015820", "015821", "015822", "015823", "015824", "015825", "015826", "015827", "015828", "015829", "015830", "015831", "015832", "015833", "015834", "015835", "015836", "015837", "015838", "015839", "015840", "015841", "015842", "015843", "015844", "015845", "015846", "015847", "015848", "015849", "015850", "015851", "015852", "015853", "015854", "015855", "015856", "015857", "015858", "015859", "015860", "015861", "015862", "015863", "015864", "015865", "015866", "015867", "015868", "015869", "015870", "015871", "015872", "015873", "015874", "015875", "015876", "015877", "015878", "015879", "015880", "015881", "015882", "015883", "015884", "015885", "015886", "015887", "015888", "015889", "015890", "015891", "015892", "015893", "015894", "015895", "015896", "015897", "015898", "015899", "015900", "015901", "015902", "015903", "015904", "015905", "015906", "015907", "016928", "016929", "016930", "016931", "016932", "016933", "016934", "016935", "016936", "016937", "016938", "016939", "016940", "016941", "016942", "016943", "016944", "016945", "016946", "016947", "016948", "016949", "016950", "016951", "016952", "016953", "016954", "016955", "016956", "016957", "016958", "016959", "016960", "016961", "016962", "016963", "016964", "016965", "016966", "016967", "016968", "016969", "016970", "016971", "016972", "016973", "016974", "016975", "016976", "016977", "016978", "016979", "016980", "016981", "016982", "016983", "016984", "016985", "016986", "016987", "016988", "016989", "016990", "016991", "016992", "016993", "016994", "016995", "016996", "016997", "016998", "016999", "017000", "017001", "017002", "017003", "017004", "017005", "017006", "017007", "017008", "017009", "017010", "017011", "017012", "017013", "017014", "017015", "017016", "017017", "017018", "017019", "017020", "017021", "017022", "017023", "017024", "017025", "017026", "017027", "017028", "017029", "017030", "017031", "017032", "017033", "017034", "017035", "017036", "017037", "017038", "017039", "017040", "017041", "017042", "017043", "017044", "017045", "017046", "017047", "017048", "017049", "017050", "017051", "017052", "017053", "017054", "017055", "017056", "017057", "017058", "017059", "017060", "017061", "017062", "017063", "017064", "017065", "017066", "017067", "017068", "017069", "017070", "017071", "017072", "017073", "017074", "017075", "017076", "017077", "017078", "017079", "017080", "017081", "017082", "017083", "017084", "017085", "017086", "017087", "017088", "017089", "017090", "017091", "017092", "017093", "017094", "017095", "017096", "017097", "017098", "017099", "017100", "017101", "017102", "017103", "017104", "017105", "017106", "017107", "017108", "017109", "017110", "017111", "017112", "017113", "017114", "017115", "017116", "017117", "017118", "017119", "017120", "017121", "017122", "017123", "017124", "017125", "017126", "017127", "017128", "017129", "017130", "017131", "017132", "017133", "017134", "017135", "017136", "017137", "017138", "017139", "017140", "017141", "017142", "017143", "017144", "017145", "017146", "017147", "017148", "017149", "017150", "017151", "017152", "017153", "017154", "017155", "017156", "017157", "017158", "017159", "017160", "017161", "017162", "017163", "017164", "017165", "017166", "017167", "017168", "017169", "017170", "017171", "017172", "017173", "017174", "017175", "017176", "017177", "017178", "017179", "017180", "017181", "017182", "017183", "017184", "017185", "017186", "017187", "017188", "017189", "017190", "017191", "017192", "017193", "017194", "017195", "017196", "017197", "017198", "017199", "017200", "017201", "017202", "017203", "017204", "017205", "017206", "017207", "017208", "017209", "017210", "017211", "017212", "017213", "017214", "017215", "017216", "017217", "017218", "017219", "017220", "017221", "017222", "017223", "017224", "017225", "017226", "017227", "017228", "017229", "017230", "017231", "017232", "017233", "017234", "017235", "017236", "017237", "017238", "017239", "017240", "017241", "017242", "017243", "017244", "017245", "017246", "017247", "017248", "017249", "017250", "017251", "017252", "017253", "017254", "017255", "017256", "017257", "017258", "017259", "017260", "017261", "017262", "017263", "017264", "017265", "017266", "017267", "017268", "017269", "017270", "017271", "017272", "017273", "017274", "017275", "017276", "017277", "017278", "017279", "017280", "017281", "017282", "017283", "017284", "017285", "017286", "017287", "017288", "017289", "017290", "017291", "017292", "017293", "017294", "017295", "017296", "017297", "017298", "017299", "017300", "017301", "017302", "017303", "017304", "017305", "017306", "017307"], "val": ["000869", "000870", "000871", "000872", "000873", "000874", "000875", "000876", "000877", "000878", "000879", "000880", "000881", "000882", "000883", "000884", "000885", "000886", "000887", "000888", "000889", "000890", "000891", "000892", "000893", "000894", "000895", "000896", "000897", "000898", "000899", "000900", "000901", "000902", "000903", "000904", "000905", "000906", "000907", "000908", "000909", "000910", "000911", "000912", "000913", "000914", "000915", "000916", "000917", "000918", "000919", "000920", "000921", "000922", "000923", "000924", "000925", "000926", "000927", "000928", "000929", "000930", "000931", "000932", "000933", "000934", "000935", "000936", "000937", "000938", "000939", "000940", "000941", "000942", "000943", "000944", "000945", "000946", "000947", "000948", "000949", "000950", "000951", "000952", "000953", "000954", "000955", "000956", "000957", "000958", "000959", "000960", "000961", "000962", "000963", "000964", "000965", "000966", "000967", "000968", "000969", "000970", "000971", "000972", "000973", "000974", "000975", "000976", "000977", "000978", "000979", "000980", "000981", "000982", "000983", "000984", "000985", "000986", "000987", "000988", "000989", "000990", "000991", "000992", "000993", "000994", "000995", "000996", "000997", "000998", "000999", "001000", "001001", "001002", "001003", "001004", "001005", "001006", "001007", "001008", "001009", "001010", "001011", "001012", "001013", "001014", "001015", "001016", "001017", "001018", "001019", "001020", "001021", "001022", "001023", "001024", "001025", "001026", "001027", "001028", "001029", "001030", "001031", "001032", "001033", "001034", "001035", "001036", "001037", "001038", "001039", "001040", "001041", "001042", "001043", "001044", "001045", "001046", "001047", "001048", "001049", "001050", "001051", "001052", "001053", "001054", "001055", "001056", "001057", "001058", "001059", "001060", "001061", "001062", "001063", "001064", "001065", "001066", "001067", "001068", "001069", "001070", "001071", "001072", "001073", "001074", "001075", "001076", "001077", "001715", "001716", "001717", "001718", "001719", "001720", "001721", "001722", "001723", "001724", "001725", "001726", "001727", "001728", "001729", "001730", "001731", "001732", "001733", "001734", "001735", "001736", "001737", "001738", "001739", "001740", "001741", "001742", "001743", "001744", "001745", "001746", "001747", "001748", "001749", "001750", "001751", "001752", "001753", "001754", "001755", "001756", "001757", "001758", "001759", "001760", "001761", "001762", "001763", "001764", "001765", "001766", "001767", "001768", "001769", "001770", "001771", "001772", "001773", "001774", "001775", "001776", "001777", "001778", "001779", "001780", "001781", "001782", "001783", "001784", "001785", "001786", "001787", "001788", "001789", "001790", "001791", "001792", "001793", "001794", "001795", "001796", "001797", "001798", "001799", "001800", "001801", "001802", "001803", "001804", "001805", "001806", "001807", "001808", "001809", "001810", "001811", "001812", "001813", "001814", "001815", "001816", "001817", "001818", "001819", "001820", "001821", "001822", "001823", "001824", "001825", "001826", "001827", "001828", "001829", "001830", "001831", "001832", "001833", "001834", "001835", "001836", "001837", "001838", "001839", "001840", "001841", "001842", "001843", "001844", "001845", "001846", "001847", "001848", "001849", "001850", "001851", "001852", "001853", "001854", "001855", "001856", "001857", "001858", "001859", "001860", "001861", "001862", "001863", "001864", "002862", "002863", "002864", "002865", "002866", "002867", "002868", "002869", "002870", "002871", "002872", "002873", "002874", "002875", "002876", "002877", "002878", "002879", "002880", "002881", "002882", "002883", "002884", "002885", "002886", "002887", "002888", "002889", "002890", "002891", "002892", "002893", "002894", "002895", "002896", "002897", "002898", "002899", "002900", "002901", "002902", "002903", "002904", "002905", "002906", "002907", "002908", "002909", "002910", "002911", "002912", "002913", "002914", "002915", "002916", "002917", "002918", "002919", "002920", "002921", "002922", "002923", "002924", "002925", "002926", "002927", "002928", "002929", "002930", "002931", "002932", "002933", "002934", "002935", "002936", "002937", "002938", "002939", "002940", "002941", "002942", "002943", "002944", "002945", "002946", "002947", "002948", "002949", "002950", "002951", "002952", "002953", "002954", "002955", "002956", "002957", "002958", "002959", "002960", "002961", "002962", "002963", "002964", "002965", "002966", "002967", "002968", "002969", "002970", "002971", "002972", "002973", "002974", "002975", "002976", "002977", "002978", "002979", "002980", "002981", "002982", "002983", "002984", "002985", "002986", "002987", "002988", "002989", "002990", "002991", "002992", "002993", "002994", "002995", "002996", "002997", "002998", "002999", "003000", "003001", "003002", "003003", "003004", "003005", "003006", "003007", "003008", "003009", "003010", "003011", "003012", "003013", "003014", "003015", "003016", "003017", "003018", "003019", "003020", "003021", "003022", "003023", "003024", "003025", "003026", "003027", "003028", "003029", "003030", "003031", "003032", "003033", "003034", "003035", "003036", "003037", "003038", "003039", "003040", "003041", "003042", "003043", "003044", "003045", "003046", "003047", "003048", "003049", "003050", "003051", "003052", "003053", "003054", "003055", "003056", "003057", "003058", "003059", "003060", "003061", "003062", "003063", "003064", "003065", "003066", "003067", "003068", "003069", "003070", "003071", "003072", "003073", "003074", "003075", "003076", "003077", "003078", "003079", "003080", "003081", "003082", "003083", "003084", "003085", "003086", "003087", "003088", "003089", "003090", "003091", "003092", "003093", "003094", "003095", "003096", "003097", "003098", "003099", "003100", "003101", "003102", "003103", "003104", "003105", "003106", "003107", "003108", "003109", "003110", "003111", "003112", "003113", "003114", "003115", "003116", "003117", "003118", "003119", "003120", "003121", "003122", "003123", "003124", "003125", "003126", "003127", "003128", "003129", "003130", "003131", "003132", "003133", "003134", "003135", "003136", "003137", "003138", "003139", "003140", "003141", "003142", "003143", "003144", "003145", "003146", "003147", "003148", "003149", "003150", "003151", "003152", "003153", "003154", "003155", "003156", "003157", "003158", "003159", "003160", "003161", "003162", "003163", "003164", "003165", "003166", "003167", "003168", "003169", "003170", "003171", "003172", "003173", "003174", "003175", "003176", "003177", "003178", "003179", "003180", "003181", "003182", "003183", "003184", "003185", "003186", "003187", "003188", "003189", "003190", "003191", "003192", "003193", "003194", "003195", "003196", "003197", "003198", "003199", "003200", "003201", "003202", "003203", "003204", "003205", "003206", "003207", "003208", "003209", "003210", "003371", "003372", "003373", "003374", "003375", "003376", "003377", "003378", "003379", "003380", "003381", "003382", "003383", "003384", "003385", "003386", "003387", "003388", "003389", "003390", "003391", "003392", "003393", "003394", "003395", "003396", "003397", "003398", "003399", "003400", "003401", "003402", "003403", "003404", "003405", "003406", "003407", "003408", "003409", "003410", "003411", "003412", "003413", "003414", "003415", "003416", "003417", "003418", "003419", "003420", "003421", "003422", "003423", "003424", "003425", "003426", "003427", "003428", "003429", "003430", "003431", "003432", "003433", "003434", "003435", "003436", "003437", "003438", "003439", "003440", "003441", "003442", "003443", "003444", "003445", "003446", "003447", "003448", "003449", "003450", "003451", "003452", "003453", "003454", "003455", "003456", "003457", "003458", "003459", "003460", "003461", "003462", "003463", "003464", "003465", "003466", "003467", "003468", "003469", "003470", "003471", "003472", "003473", "003474", "003475", "003476", "003477", "003478", "003479", "003480", "003481", "003482", "003483", "003484", "003485", "003486", "003487", "003488", "003489", "003490", "003861", "003862", "003863", "003864", "003865", "003866", "003867", "003868", "003869", "003870", "003871", "003872", "003873", "003874", "003875", "003876", "003877", "003878", "003879", "003880", "003881", "003882", "003883", "003884", "003885", "003886", "003887", "003888", "003889", "003890", "003891", "003892", "003893", "003894", "003895", "003896", "003897", "003898", "003899", "003900", "003901", "003902", "003903", "003904", "003905", "003906", "003907", "003908", "003909", "003910", "003911", "003912", "003913", "003914", "003915", "003916", "003917", "003918", "003919", "003920", "003921", "003922", "003923", "003924", "003925", "003926", "003927", "003928", "003929", "003930", "003931", "003932", "003933", "003934", "003935", "003936", "003937", "003938", "003939", "003940", "003941", "003942", "003943", "003944", "003945", "003946", "003947", "003948", "003949", "003950", "003951", "003952", "003953", "003954", "003955", "003956", "003957", "003958", "003959", "003960", "003961", "003962", "003963", "003964", "003965", "003966", "003967", "003968", "003969", "003970", "003971", "003972", "003973", "003974", "003975", "003976", "003977", "003978", "003979", "003980", "003981", "003982", "003983", "003984", "003985", "003986", "003987", "003988", "003989", "003990", "003991", "003992", "003993", "003994", "003995", "003996", "003997", "003998", "003999", "004000", "004001", "004002", "004003", "004004", "004005", "004006", "004007", "004008", "004009", "004010", "004011", "004012", "004013", "004014", "004015", "004016", "004017", "004018", "004019", "004020", "004021", "004022", "004023", "004024", "004025", "004026", "004027", "004028", "004029", "004030", "004031", "004032", "004033", "004034", "004035", "004036", "004037", "004038", "004039", "004040", "004041", "004042", "004043", "004044", "004045", "004046", "004047", "004048", "004049", "004050", "004051", "004052", "004053", "004054", "004055", "004056", "004057", "004058", "004059", "004060", "004061", "004062", "004063", "004064", "004065", "004066", "004067", "004068", "004069", "004070", "004071", "004072", "004073", "004074", "004075", "004076", "004077", "004078", "004079", "004080", "004081", "004082", "004083", "004084", "004085", "004086", "004087", "004088", "004089", "004090", "004091", "004092", "004093", "004094", "004095", "004096", "004097", "004098", "004099", "004100", "004101", "004102", "004103", "004104", "004105", "004106", "004107", "004108", "004109", "004110", "004111", "004112", "004113", "004114", "004115", "004116", "004117", "004118", "004119", "004120", "004121", "004122", "004123", "004124", "004125", "004126", "004127", "004128", "004129", "004130", "004131", "004132", "004133", "004134", "004135", "004136", "004137", "004138", "004139", "004140", "004141", "004142", "004143", "004144", "004145", "004146", "004147", "004148", "004149", "004150", "004151", "004152", "004153", "004154", "004155", "004156", "004157", "004158", "004159", "004160", "004161", "004162", "004163", "004164", "004165", "004166", "004167", "004168", "004169", "004170", "004171", "004172", "004173", "004174", "004175", "004176", "004177", "004178", "004179", "004180", "004181", "004182", "004183", "004184", "004185", "004186", "004187", "004188", "004189", "004190", "004191", "004192", "004193", "004194", "004195", "004196", "004197", "004198", "004199", "004200", "004201", "004202", "004203", "004204", "004205", "004206", "004207", "004208", "004209", "004210", "004211", "004212", "004213", "004214", "004215", "004216", "004217", "004218", "004219", "004220", "004221", "004222", "004223", "004224", "004225", "004226", "004227", "004228", "004229", "004230", "004231", "004232", "004233", "004234", "004235", "004236", "004237", "004238", "004239", "004240", "004241", "004242", "004243", "004244", "004245", "004246", "004247", "004248", "004249", "004250", "004251", "004252", "004253", "004254", "004255", "004256", "004257", "004258", "004259", "004260", "007626", "007627", "007628", "007629", "007630", "007631", "007632", "007633", "007634", "007635", "007636", "007637", "007638", "007639", "007640", "007641", "007642", "007643", "007644", "007645", "007646", "007647", "007648", "007649", "007650", "007651", "007652", "007653", "007654", "007655", "007656", "007657", "007658", "007659", "007660", "007661", "007662", "007663", "007664", "007665", "007666", "007667", "007668", "007669", "007670", "007671", "007672", "007673", "007674", "007675", "007676", "007677", "007678", "007679", "007680", "007681", "007682", "007683", "007684", "007685", "007686", "007687", "007688", "007689", "007690", "007691", "007692", "007693", "007694", "007695", "007696", "007697", "007698", "007699", "007700", "007701", "007702", "007703", "007704", "007705", "007706", "007707", "007708", "007709", "007710", "007711", "007712", "007713", "007714", "007715", "007716", "007717", "007718", "007719", "007720", "007721", "007722", "007723", "007724", "007725", "007726", "007727", "007728", "007729", "007730", "007731", "007732", "007733", "007734", "007735", "007736", "007737", "007738", "007739", "007740", "007741", "007742", "007743", "007744", "007745", "007746", "007747", "007748", "007749", "007750", "007751", "007752", "007753", "007754", "007755", "007756", "007757", "007758", "007759", "007760", "007761", "007762", "007763", "007764", "007765", "007766", "007767", "007768", "007769", "007770", "007771", "007772", "007773", "007774", "007775", "007776", "007777", "007778", "007779", "007780", "007781", "007782", "007783", "007784", "007785", "007786", "007787", "007788", "007789", "007790", "007791", "007792", "007793", "007794", "007795", "009361", "009362", "009363", "009364", "009365", "009366", "009367", "009368", "009369", "009370", "009371", "009372", "009373", "009374", "009375", "009376", "009377", "009378", "009379", "009380", "009381", "009382", "009383", "009384", "009385", "009386", "009387", "009388", "009389", "009390", "009391", "009392", "009393", "009394", "009395", "009396", "009397", "009398", "009399", "009400", "009401", "009402", "009403", "009404", "009405", "009406", "009407", "009408", "009409", "009410", "009411", "009412", "009413", "009414", "009415", "009416", "009417", "009418", "009419", "009420", "009421", "009422", "009423", "009424", "009425", "009426", "009427", "009428", "009429", "009430", "009431", "009432", "009433", "009434", "009435", "009436", "009437", "009438", "009439", "009440", "009441", "009442", "009443", "009444", "009445", "009446", "009447", "009448", "009449", "009450", "009451", "009452", "009453", "009454", "009455", "009456", "009457", "009458", "009459", "009460", "009461", "009462", "009463", "009464", "009465", "009466", "009467", "009468", "009469", "009470", "009471", "009472", "009473", "009474", "009475", "009476", "009477", "009478", "009479", "009480", "009481", "009482", "009483", "009484", "009485", "009486", "009487", "009488", "009489", "009490", "009491", "009492", "009493", "009494", "009495", "009496", "009497", "009498", "009499", "009500", "010481", "010482", "010483", "010484", "010485", "010486", "010487", "010488", "010489", "010490", "010491", "010492", "010493", "010494", "010495", "010496", "010497", "010498", "010499", "010500", "010501", "010502", "010503", "010504", "010505", "010506", "010507", "010508", "010509", "010510", "010511", "010512", "010513", "010514", "010515", "010516", "010517", "010518", "010519", "010520", "010521", "010522", "010523", "010524", "010525", "010526", "010527", "010528", "010529", "010530", "010531", "010532", "010533", "010534", "010535", "010536", "010537", "010538", "010539", "010540", "010541", "010542", "010543", "010544", "010545", "010546", "010547", "010548", "010549", "010550", "010551", "010552", "010553", "010554", "010555", "010556", "010557", "010558", "010559", "010560", "010561", "010562", "010563", "010564", "010565", "010566", "010567", "010568", "010569", "010570", "010571", "010572", "010573", "010574", "010575", "010576", "010577", "010578", "010579", "010580", "010581", "010582", "010583", "010584", "010585", "010586", "010587", "010588", "010589", "010590", "010591", "010592", "010593", "010594", "010595", "010596", "010597", "010598", "010599", "010600", "010601", "010602", "010603", "010604", "010605", "010606", "010607", "010608", "010609", "010610", "010611", "010612", "010613", "010614", "010615", "010616", "010617", "010618", "010619", "010620", "010621", "010622", "010623", "010624", "010625", "010626", "010627", "010628", "010629", "010630", "010631", "010632", "010633", "010634", "010635", "010636", "010637", "010638", "010639", "010640", "010641", "010642", "010643", "010644", "010645", "010646", "010647", "010648", "010649", "010650", "010651", "010652", "010653", "010654", "010655", "010656", "010657", "010658", "010659", "010660", "010661", "010662", "010663", "010664", "010665", "010666", "010667", "010668", "010669", "010670", "010671", "010672", "010673", "010674", "010675", "010676", "010677", "010678", "010679", "010680", "010681", "010682", "010683", "010684", "010685", "010686", "010687", "010688", "010689", "010690", "010691", "010692", "010693", "010694", "010695", "010696", "010697", "010698", "010699", "010700", "010701", "010702", "010703", "010704", "010705", "010706", "010707", "010708", "010709", "010710", "010711", "010712", "010713", "010714", "010715", "010716", "010717", "010718", "010719", "010720", "010721", "010722", "010723", "010724", "010725", "010726", "010727", "010728", "010729", "010730", "010731", "010732", "010733", "010734", "010735", "010736", "010737", "010738", "010739", "010740", "010741", "010742", "010743", "010744", "010745", "010746", "010747", "010748", "010749", "010750", "010751", "010752", "010753", "010754", "010755", "010756", "010757", "010758", "010759", "010760", "010761", "010762", "010763", "010764", "010765", "010766", "010767", "010768", "010769", "010770", "010771", "010772", "010773", "010774", "010775", "010776", "010777", "010778", "010779", "010780", "010781", "010782", "010783", "010784", "010785", "010786", "010787", "010788", "010789", "010790", "010791", "010792", "010793", "010794", "010795", "010796", "010797", "010798", "010799", "010800", "010801", "010802", "010803", "010804", "010805", "010806", "010807", "010808", "010809", "010810", "010811", "010812", "010813", "010814", "010815", "010816", "010817", "010818", "010819", "010820", "010821", "010822", "010823", "010824", "010825", "010826", "010827", "010828", "010829", "010830", "010831", "010832", "010833", "010834", "010835", "010836", "010837", "010838", "010839", "010840", "010841", "010842", "010843", "010844", "010845", "010846", "010847", "010848", "010849", "010850", "010851", "010852", "010853", "010854", "010855", "010856", "010857", "010858", "010859", "010860", "010861", "010862", "010863", "010864", "010865", "010866", "010867", "010868", "010869", "010870", "010871", "010872", "010873", "010874", "010875", "010876", "010877", "010878", "010879", "010880", "010881", "010882", "010883", "010884", "010885", "010886", "010887", "010888", "010889", "010890", "010891", "010892", "010893", "010894", "010895", "010896", "010897", "010898", "010899", "010900", "010901", "010902", "010903", "010904", "010905", "010906", "010907", "010908", "010909", "010910", "010911", "010912", "010913", "010914", "010915", "010916", "010917", "010918", "010919", "010920", "010921", "010922", "010923", "010924", "010925", "010926", "010927", "010928", "010929", "010930", "010931", "010932", "010933", "010934", "010935", "010936", "010937", "010938", "010939", "010940", "011151", "011152", "011153", "011154", "011155", "011156", "011157", "011158", "011159", "011160", "011161", "011162", "011163", "011164", "011165", "011166", "011167", "011168", "011169", "011170", "011171", "011172", "011173", "011174", "011175", "011176", "011177", "011178", "011179", "011180", "011181", "011182", "011183", "011184", "011185", "011186", "011187", "011188", "011189", "011190", "011191", "011192", "011193", "011194", "011195", "011196", "011197", "011198", "011199", "011200", "011201", "011202", "011203", "011204", "011205", "011206", "011207", "011208", "011209", "011210", "011211", "011212", "011213", "011214", "011215", "011216", "011217", "011218", "011219", "011220", "011221", "011222", "011223", "011224", "011225", "011226", "011227", "011228", "011229", "011230", "011231", "011232", "011233", "011234", "011235", "011236", "011237", "011238", "011239", "011240", "011241", "011242", "011243", "011244", "011245", "011246", "011247", "011248", "011249", "011250", "011251", "011252", "011253", "011254", "011255", "011256", "011257", "011258", "011259", "011260", "011451", "011452", "011453", "011454", "011455", "011456", "011457", "011458", "011459", "011460", "011461", "011462", "011463", "011464", "011465", "011466", "011467", "011468", "011469", "011470", "011471", "011472", "011473", "011474", "011475", "011476", "011477", "011478", "011479", "011480", "011481", "011482", "011483", "011484", "011485", "011486", "011487", "011488", "011489", "011490", "011491", "011492", "011493", "011494", "011495", "011496", "011497", "011498", "011499", "011500", "011501", "011502", "011503", "011504", "011505", "011506", "011507", "011508", "011509", "011510", "011511", "011512", "011513", "011514", "011515", "011516", "011517", "011518", "011519", "011520", "011521", "011522", "011523", "011524", "011525", "011526", "011527", "011528", "011529", "011530", "011531", "011532", "011533", "011534", "011535", "011536", "011537", "011538", "011539", "011540", "011541", "011542", "011543", "011544", "011545", "011546", "011547", "011548", "011549", "011550", "011551", "011552", "011553", "011554", "011555", "011556", "011557", "011558", "011559", "011560", "011561", "011562", "011563", "011564", "011565", "011566", "011567", "011568", "011569", "011570", "011571", "011572", "011573", "011574", "011575", "011576", "011577", "011578", "011579", "011580", "011581", "011582", "011583", "011584", "011585", "011586", "011587", "011588", "011589", "011590", "011591", "011592", "011593", "011594", "011595", "011596", "011597", "011598", "011599", "011600", "011601", "011602", "011603", "011604", "011605", "011606", "011607", "011608", "011609", "011610", "011611", "011612", "011613", "011614", "011615", "011616", "011617", "011618", "011619", "011620", "011621", "011622", "011623", "011624", "011625", "011626", "011627", "011628", "011629", "011630", "011631", "011632", "011633", "011634", "011635", "011636", "011637", "011638", "011639", "011640", "013210", "013211", "013212", "013213", "013214", "013215", "013216", "013217", "013218", "013219", "013220", "013221", "013222", "013223", "013224", "013225", "013226", "013227", "013228", "013229", "013230", "013231", "013232", "013233", "013234", "013235", "013236", "013237", "013238", "013239", "013240", "013241", "013242", "013243", "013244", "013245", "013246", "013247", "013248", "013249", "013250", "013251", "013252", "013253", "013254", "013255", "013256", "013257", "013258", "013259", "013260", "013261", "013262", "013263", "013264", "013265", "013266", "013267", "013268", "013269", "013270", "013271", "013272", "013273", "013274", "013275", "013276", "013277", "013278", "013279", "013280", "013281", "013282", "013283", "013284", "013285", "013286", "013287", "013288", "013289", "013290", "013291", "013292", "013293", "013294", "013295", "013296", "013297", "013298", "013299", "013300", "013301", "013302", "013303", "013304", "013305", "013306", "013307", "013308", "013309", "013310", "013311", "013312", "013313", "013314", "013315", "013316", "013317", "013318", "013319", "013320", "013321", "013322", "013323", "013324", "013325", "013326", "013327", "013328", "013329", "013330", "013331", "013332", "013333", "013334", "013335", "013336", "013337", "013338", "013339", "013340", "013341", "013342", "013343", "013344", "013345", "013346", "013347", "013348", "013349", "013350", "013351", "013352", "013353", "013354", "013355", "013356", "013357", "013358", "013359", "013360", "013361", "013362", "013363", "013364", "013365", "013366", "013367", "013368", "013369", "013370", "013371", "013372", "013373", "013374", "013375", "013376", "013377", "013378", "013379", "013380", "013381", "013382", "013383", "013384", "013385", "013386", "013387", "013388", "013389", "013390", "013391", "013392", "013393", "013394", "013395", "013396", "013397", "013398", "013399", "013400", "013401", "013402", "013403", "013404", "013405", "013406", "013407", "013408", "013409", "013410", "013411", "013412", "013413", "013414", "013415", "013416", "013417", "013418", "013419", "013700", "013701", "013702", "013703", "013704", "013705", "013706", "013707", "013708", "013709", "013710", "013711", "013712", "013713", "013714", "013715", "013716", "013717", "013718", "013719", "013720", "013721", "013722", "013723", "013724", "013725", "013726", "013727", "013728", "013729", "013730", "013731", "013732", "013733", "013734", "013735", "013736", "013737", "013738", "013739", "013740", "013741", "013742", "013743", "013744", "013745", "013746", "013747", "013748", "013749", "013750", "013751", "013752", "013753", "013754", "013755", "013756", "013757", "013758", "013759", "013760", "013761", "013762", "013763", "013764", "013765", "013766", "013767", "013768", "013769", "013770", "013771", "013772", "013773", "013774", "013775", "013776", "013777", "013778", "013779", "013780", "013781", "013782", "013783", "013784", "013785", "013786", "013787", "013788", "013789", "013790", "013791", "013792", "013793", "013794", "013795", "013796", "013797", "013798", "013799", "013800", "013801", "013802", "013803", "013804", "013805", "013806", "013807", "013808", "013809", "013810", "013811", "013812", "013813", "013814", "013815", "013816", "013817", "013818", "013819", "013820", "013821", "013822", "013823", "013824", "013825", "013826", "013827", "013828", "013829", "013830", "013831", "013832", "013833", "013834", "013835", "013836", "013837", "013838", "013839", "013840", "013841", "013842", "013843", "013844", "013845", "013846", "013847", "013848", "013849", "013850", "013851", "013852", "013853", "013854", "013855", "013856", "013857", "013858", "013859", "013860", "013861", "013862", "013863", "013864", "013865", "013866", "013867", "013868", "013869", "013870", "013871", "013872", "013873", "013874", "013875", "013876", "013877", "013878", "013879", "013880", "013881", "013882", "013883", "013884", "013885", "013886", "013887", "013888", "013889", "013938", "013939", "013940", "013941", "013942", "013943", "013944", "013945", "013946", "013947", "013948", "013949", "013950", "013951", "013952", "013953", "013954", "013955", "013956", "013957", "013958", "013959", "013960", "013961", "013962", "013963", "013964", "013965", "013966", "013967", "013968", "013969", "013970", "013971", "013972", "013973", "013974", "013975", "013976", "013977", "013978", "013979", "013980", "013981", "013982", "013983", "013984", "013985", "013986", "013987", "013988", "013989", "013990", "013991", "013992", "013993", "013994", "013995", "013996", "013997", "013998", "013999", "014000", "014001", "014002", "014003", "014004", "014005", "014006", "014007", "014008", "014009", "014010", "014011", "014012", "014013", "014014", "014015", "014016", "014017", "014018", "014019", "014020", "014021", "014022", "014023", "014024", "014025", "014026", "014027", "014028", "014029", "014030", "014031", "014032", "014033", "014034", "014035", "014036", "014037", "015408", "015409", "015410", "015411", "015412", "015413", "015414", "015415", "015416", "015417", "015418", "015419", "015420", "015421", "015422", "015423", "015424", "015425", "015426", "015427", "015428", "015429", "015430", "015431", "015432", "015433", "015434", "015435", "015436", "015437", "015438", "015439", "015440", "015441", "015442", "015443", "015444", "015445", "015446", "015447", "015448", "015449", "015450", "015451", "015452", "015453", "015454", "015455", "015456", "015457", "015458", "015459", "015460", "015461", "015462", "015463", "015464", "015465", "015466", "015467", "015468", "015469", "015470", "015471", "015472", "015473", "015474", "015475", "015476", "015477", "015478", "015479", "015480", "015481", "015482", "015483", "015484", "015485", "015486", "015487", "015488", "015489", "015490", "015491", "015492", "015493", "015494", "015495", "015496", "015497", "015498", "015499", "015500", "015501", "015502", "015503", "015504", "015505", "015506", "015507", "015508", "015509", "015510", "015511", "015512", "015513", "015514", "015515", "015516", "015517", "015518", "015519", "015520", "015521", "015522", "015523", "015524", "015525", "015526", "015527", "015528", "015529", "015530", "015531", "015532", "015533", "015534", "015535", "015536", "015537", "015538", "015539", "015540", "015541", "015542", "015543", "015544", "015545", "015546", "015547", "015548", "015549", "015550", "015551", "015552", "015553", "015554", "015555", "015556", "015557", "015558", "015559", "015560", "015561", "015562", "015563", "015564", "015565", "015566", "015567", "015568", "015569", "015570", "015571", "015572", "015573", "015574", "015575", "015576", "015577", "015578", "015579", "015580", "015581", "015582", "015583", "015584", "015585", "015586", "015587", "015588", "015589", "015590", "015591", "015592", "015593", "015594", "015595", "015596", "015597", "015598", "015599", "015600", "015601", "015602", "015603", "015604", "015605", "015606", "015607", "015608", "015609", "015610", "015611", "015612", "015613", "015614", "015615", "015616", "015617", "015618", "015619", "015620", "015621", "015622", "015623", "015624", "015625", "015626", "015627", "015628", "015629", "015630", "015631", "015632", "015633", "015634", "015635", "015636", "015637", "015638", "015639", "015640", "015641", "015642", "015643", "015644", "015645", "015646", "015647", "015648", "015649", "015650", "015651", "015652", "015653", "015654", "015655", "015656", "015657", "015658", "015659", "015660", "015661", "015662", "015663", "015664", "015665", "015666", "015667", "015668", "015669", "015670", "015671", "015672", "015673", "015674", "015675", "015676", "015677", "015678", "015679", "015680", "015681", "015682", "015683", "015684", "015685", "015686", "015687", "015688", "015689", "015690", "015691", "015692", "015693", "015694", "015695", "015696", "015697", "015698", "015699", "015700", "015701", "015702", "015703", "015704", "015705", "015706", "015707", "015708", "015709", "015710", "015711", "015712", "015713", "015714", "015715", "015716", "015717", "015718", "015719", "015720", "015721", "015722", "015723", "015724", "015725", "015726", "015727", "015728", "015729", "015730", "015731", "015732", "015733", "015734", "015735", "015736", "015737", "015738", "015739", "015740", "015741", "015742", "015743", "015744", "015745", "015746", "015747", "015748", "015749", "015750", "015751", "015752", "015753", "015754", "015755", "015756", "015757", "015758", "015759", "015760", "015761", "015762", "015763", "015764", "015765", "015766", "015767", "015908", "015909", "015910", "015911", "015912", "015913", "015914", "015915", "015916", "015917", "015918", "015919", "015920", "015921", "015922", "015923", "015924", "015925", "015926", "015927", "015928", "015929", "015930", "015931", "015932", "015933", "015934", "015935", "015936", "015937", "015938", "015939", "015940", "015941", "015942", "015943", "015944", "015945", "015946", "015947", "015948", "015949", "015950", "015951", "015952", "015953", "015954", "015955", "015956", "015957", "015958", "015959", "015960", "015961", "015962", "015963", "015964", "015965", "015966", "015967", "015968", "015969", "015970", "015971", "015972", "015973", "015974", "015975", "015976", "015977", "015978", "015979", "015980", "015981", "015982", "015983", "015984", "015985", "015986", "015987", "015988", "015989", "015990", "015991", "015992", "015993", "015994", "015995", "015996", "015997", "015998", "015999", "016000", "016001", "016002", "016003", "016004", "016005", "016006", "016007", "016008", "016009", "016010", "016011", "016012", "016013", "016014", "016015", "016016", "016017", "016018", "016019", "016020", "016021", "016022", "016023", "016024", "016025", "016026", "016027", "016028", "016029", "016030", "016031", "016032", "016033", "016034", "016035", "016036", "016037", "016038", "016039", "016040", "016041", "016042", "016043", "016044", "016045", "016046", "016047", "016048", "016049", "016050", "016051", "016052", "016053", "016054", "016055", "016056", "016057", "016058", "016059", "016060", "016061", "016062", "016063", "016064", "016065", "016066", "016067", "016068", "016069", "016070", "016071", "016072", "016073", "016074", "016075", "016076", "016077", "016078", "016079", "016080", "016081", "016082", "016083", "016084", "016085", "016086", "016087", "016088", "016089", "016090", "016091", "016092", "016093", "016094", "016095", "016096", "016097", "016098", "016099", "016100", "016101", "016102", "016103", "016104", "016105", "016106", "016107", "016108", "016109", "016110", "016111", "016112", "016113", "016114", "016115", "016116", "016117", "016118", "016119", "016120", "016121", "016122", "016123", "016124", "016125", "016126", "016127", "016128", "016129", "016130", "016131", "016132", "016133", "016134", "016135", "016136", "016137", "016138", "016139", "016140", "016141", "016142", "016143", "016144", "016145", "016146", "016147", "016148", "016149", "016150", "016151", "016152", "016153", "016154", "016155", "016156", "016157", "016158", "016159", "016160", "016161", "016162", "016163", "016164", "016165", "016166", "016167", "016168", "016169", "016170", "016171", "016172", "016173", "016174", "016175", "016176", "016177", "016178", "016179", "016180", "016181", "016182", "016183", "016184", "016185", "016186", "016187", "016188", "016189", "016190", "016191", "016192", "016193", "016194", "016195", "016196", "016197", "016198", "016199", "016200", "016201", "016202", "016203", "016204", "016205", "016206", "016207", "016208", "016209", "016210", "016211", "016212", "016213", "016214", "016215", "016216", "016217", "016218", "016219", "016220", "016221", "016222", "016223", "016224", "016225", "016226", "016227", "016228", "016229", "016230", "016231", "016232", "016233", "016234", "016235", "016236", "016237", "016238", "016239", "016240", "016241", "016242", "016243", "016244", "016245", "016246", "016247", "016248", "016249", "016250", "016251", "016252", "016253", "016254", "016255", "016256", "016257", "016258", "016259", "016260", "016261", "016262", "016263", "016264", "016265", "016266", "016267", "016698", "016699", "016700", "016701", "016702", "016703", "016704", "016705", "016706", "016707", "016708", "016709", "016710", "016711", "016712", "016713", "016714", "016715", "016716", "016717", "016718", "016719", "016720", "016721", "016722", "016723", "016724", "016725", "016726", "016727", "016728", "016729", "016730", "016731", "016732", "016733", "016734", "016735", "016736", "016737", "016738", "016739", "016740", "016741", "016742", "016743", "016744", "016745", "016746", "016747", "016748", "016749", "016750", "016751", "016752", "016753", "016754", "016755", "016756", "016757", "016758", "016759", "016760", "016761", "016762", "016763", "016764", "016765", "016766", "016767", "016768", "016769", "016770", "016771", "016772", "016773", "016774", "016775", "016776", "016777", "016778", "016779", "016780", "016781", "016782", "016783", "016784", "016785", "016786", "016787", "016788", "016789", "016790", "016791", "016792", "016793", "016794", "016795", "016796", "016797", "016798", "016799", "016800", "016801", "016802", "016803", "016804", "016805", "016806", "016807", "016808", "016809", "016810", "016811", "016812", "016813", "016814", "016815", "016816", "016817", "016818", "016819", "016820", "016821", "016822", "016823", "016824", "016825", "016826", "016827", "016828", "016829", "016830", "016831", "016832", "016833", "016834", "016835", "016836", "016837", "016838", "016839", "016840", "016841", "016842", "016843", "016844", "016845", "016846", "016847", "016848", "016849", "016850", "016851", "016852", "016853", "016854", "016855", "016856", "016857", "016858", "016859", "016860", "016861", "016862", "016863", "016864", "016865", "016866", "016867", "016868", "016869", "016870", "016871", "016872", "016873", "016874", "016875", "016876", "016877", "016878", "016879", "016880", "016881", "016882", "016883", "016884", "016885", "016886", "016887", "016888", "016889", "016890", "016891", "016892", "016893", "016894", "016895", "016896", "016897", "016898", "016899", "016900", "016901", "016902", "016903", "016904", "016905", "016906", "016907", "016908", "016909", "016910", "016911", "016912", "016913", "016914", "016915", "016916", "016917", "016918", "016919", "016920", "016921", "016922", "016923", "016924", "016925", "016926", "016927"], "test": ["001516", "001517", "001518", "001519", "001520", "001521", "001522", "001523", "001524", "001525", "001526", "001527", "001528", "001529", "001530", "001531", "001532", "001533", "001534", "001535", "001536", "001537", "001538", "001539", "001540", "001541", "001542", "001543", "001544", "001545", "001546", "001547", "001548", "001549", "001550", "001551", "001552", "001553", "001554", "001555", "001556", "001557", "001558", "001559", "001560", "001561", "001562", "001563", "001564", "001565", "001566", "001567", "001568", "001569", "001570", "001571", "001572", "001573", "001574", "001575", "001576", "001577", "001578", "001579", "001580", "001581", "001582", "001583", "001584", "001585", "001586", "001587", "001588", "001589", "001590", "001591", "001592", "001593", "001594", "001595", "001596", "001597", "001598", "001599", "001600", "001601", "001602", "001603", "001604", "001605", "001606", "001607", "001608", "001609", "001610", "001611", "001612", "001613", "001614", "001615", "001616", "001617", "001618", "001619", "001620", "001621", "001622", "001623", "001624", "001625", "001626", "001627", "001628", "001629", "001630", "001631", "001632", "001633", "001634", "001635", "001636", "001637", "001638", "001639", "001640", "001641", "001642", "001643", "001644", "001645", "001646", "001647", "001648", "001649", "001650", "001651", "001652", "001653", "001654", "001655", "001656", "001657", "001658", "001659", "001660", "001661", "001662", "001663", "001664", "001665", "001666", "001667", "001668", "001669", "001670", "001671", "001672", "001673", "001674", "001675", "001676", "001677", "001678", "001679", "001680", "001681", "001682", "001683", "001684", "001685", "001686", "001687", "001688", "001689", "001690", "001691", "001692", "001693", "001694", "001695", "001696", "001697", "001698", "001699", "001700", "001701", "001702", "001703", "001704", "001705", "001706", "001707", "001708", "001709", "001710", "001711", "001712", "001713", "001714", "002065", "002066", "002067", "002068", "002069", "002070", "002071", "002072", "002073", "002074", "002075", "002076", "002077", "002078", "002079", "002080", "002081", "002082", "002083", "002084", "002085", "002086", "002087", "002088", "002089", "002090", "002091", "002092", "002093", "002094", "002095", "002096", "002097", "002098", "002099", "002100", "002101", "002102", "002103", "002104", "002105", "002106", "002107", "002108", "002109", "002110", "002111", "002112", "002113", "002114", "002115", "002116", "002117", "002118", "002119", "002120", "002121", "002122", "002123", "002124", "002125", "002126", "002127", "002128", "002129", "002130", "002131", "002132", "002133", "002134", "002135", "002136", "002137", "002138", "002139", "002140", "002141", "002142", "002143", "002144", "002145", "002146", "002147", "002148", "002149", "002150", "002151", "002152", "002153", "002154", "002155", "002156", "002157", "002158", "002159", "002160", "002161", "002162", "002163", "002164", "002165", "002166", "002167", "002168", "002169", "002170", "002171", "002172", "002173", "002174", "002175", "002176", "002177", "002178", "002179", "002180", "002181", "002182", "002183", "002184", "002185", "002186", "002187", "002188", "002189", "002190", "002191", "002192", "002193", "002194", "002195", "002196", "002197", "002198", "002199", "002200", "002201", "002202", "002203", "002204", "002205", "002206", "002207", "002208", "002209", "002210", "002211", "002212", "002213", "002214", "002215", "002216", "002217", "002218", "002219", "002220", "002221", "002222", "002223", "002224", "002225", "002226", "002227", "002228", "002229", "002230", "002231", "002232", "002233", "002234", "002235", "002236", "002237", "002238", "002239", "002240", "002241", "002242", "002243", "002383", "002384", "002385", "002386", "002387", "002388", "002389", "002390", "002391", "002392", "002393", "002394", "002395", "002396", "002397", "002398", "002399", "002400", "002401", "002402", "002403", "002404", "002405", "002406", "002407", "002408", "002409", "002410", "002411", "002412", "002413", "002414", "002415", "002416", "002417", "002418", "002419", "002420", "002421", "002422", "002423", "002424", "002425", "002426", "002427", "002428", "002429", "002430", "002431", "002432", "002433", "002434", "002435", "002436", "002437", "002438", "002439", "002440", "002441", "002442", "002443", "002444", "002445", "002446", "002447", "002448", "002449", "002450", "002451", "002452", "002453", "002454", "002455", "002456", "002457", "002458", "002459", "002460", "002461", "002462", "002463", "002464", "002465", "002466", "002467", "002468", "002469", "002470", "002471", "002472", "002473", "002474", "002475", "002476", "002477", "002478", "002479", "002480", "002481", "002482", "002483", "002484", "002485", "002486", "002487", "002488", "002489", "002490", "002491", "002492", "002493", "002494", "002495", "002496", "002497", "002498", "002499", "002500", "002501", "002502", "002503", "002504", "002505", "002506", "002507", "002508", "002509", "002510", "002511", "002512", "002513", "002514", "002515", "002516", "002517", "002518", "002519", "002520", "002521", "002522", "002523", "002524", "002525", "002526", "002527", "002528", "002529", "002530", "002531", "002532", "002533", "002534", "002535", "002536", "002537", "002538", "002539", "002540", "002541", "002542", "002543", "002544", "002545", "002546", "002547", "002548", "002549", "002550", "002551", "002552", "002553", "002554", "002555", "002556", "002557", "002558", "002559", "002560", "002561", "002562", "002563", "002564", "002565", "002566", "002567", "002568", "002569", "002570", "002571", "002572", "002573", "002574", "002575", "002576", "002577", "002578", "002579", "002580", "002581", "002582", "002583", "002584", "002585", "002586", "002587", "002588", "002589", "002590", "002591", "002592", "002593", "002594", "002595", "002596", "002597", "002598", "002599", "002600", "002601", "002602", "002603", "002604", "002605", "002606", "002607", "002608", "002609", "002610", "002611", "002612", "002613", "002614", "002615", "002616", "002617", "002618", "002619", "002620", "002621", "002622", "002623", "002624", "002625", "002626", "002627", "002628", "002629", "002630", "002631", "002632", "002633", "002634", "002635", "002636", "002637", "002638", "002639", "002640", "002641", "002642", "002643", "002644", "002645", "002646", "002647", "002648", "002649", "002650", "002651", "002652", "002653", "002654", "002655", "002656", "002657", "002658", "002659", "002660", "002661", "002662", "002663", "002664", "002665", "002666", "002667", "002668", "002669", "002670", "002671", "002672", "002673", "002674", "002675", "002676", "002677", "002678", "002679", "002680", "002681", "002682", "002683", "002684", "002685", "002686", "002687", "002688", "002689", "002690", "002691", "002692", "002693", "002694", "002695", "002696", "002697", "002698", "002699", "002700", "002701", "002702", "002703", "002704", "002705", "002706", "002707", "002708", "002709", "002710", "002711", "002712", "002713", "002714", "002715", "002716", "002717", "002718", "002719", "002720", "002721", "002722", "002723", "002724", "002725", "002726", "002727", "002728", "002729", "002730", "002731", "002732", "002733", "002734", "002735", "002736", "002737", "002738", "002739", "002740", "002741", "002742", "002743", "002744", "002745", "002746", "002747", "002748", "002749", "002750", "002751", "002752", "002753", "002754", "002755", "002756", "002757", "002758", "002759", "002760", "002761", "002762", "002763", "002764", "002765", "002766", "002767", "002768", "002769", "002770", "002771", "002772", "002773", "002774", "002775", "002776", "002777", "002778", "002779", "002780", "002781", "002782", "002783", "002784", "002785", "002786", "002787", "002788", "002789", "002790", "002791", "002792", "002793", "002794", "002795", "002796", "002797", "002798", "002799", "002800", "002801", "002802", "002803", "002804", "002805", "002806", "002807", "002808", "002809", "002810", "002811", "002812", "002813", "002814", "002815", "002816", "002817", "002818", "002819", "002820", "002821", "002822", "002823", "002824", "002825", "002826", "002827", "002828", "002829", "002830", "002831", "002832", "002833", "002834", "002835", "002836", "002837", "002838", "002839", "002840", "002841", "002842", "002843", "002844", "002845", "002846", "002847", "002848", "002849", "002850", "002851", "002852", "002853", "002854", "002855", "002856", "002857", "002858", "002859", "002860", "002861", "003641", "003642", "003643", "003644", "003645", "003646", "003647", "003648", "003649", "003650", "003651", "003652", "003653", "003654", "003655", "003656", "003657", "003658", "003659", "003660", "003661", "003662", "003663", "003664", "003665", "003666", "003667", "003668", "003669", "003670", "003671", "003672", "003673", "003674", "003675", "003676", "003677", "003678", "003679", "003680", "003681", "003682", "003683", "003684", "003685", "003686", "003687", "003688", "003689", "003690", "003691", "003692", "003693", "003694", "003695", "003696", "003697", "003698", "003699", "003700", "003701", "003702", "003703", "003704", "003705", "003706", "003707", "003708", "003709", "003710", "003711", "003712", "003713", "003714", "003715", "003716", "003717", "003718", "003719", "003720", "003721", "003722", "003723", "003724", "003725", "003726", "003727", "003728", "003729", "003730", "003731", "003732", "003733", "003734", "003735", "003736", "003737", "003738", "003739", "003740", "003741", "003742", "003743", "003744", "003745", "003746", "003747", "003748", "003749", "003750", "003751", "003752", "003753", "003754", "003755", "003756", "003757", "003758", "003759", "003760", "003761", "003762", "003763", "003764", "003765", "003766", "003767", "003768", "003769", "003770", "003771", "003772", "003773", "003774", "003775", "003776", "003777", "003778", "003779", "003780", "003781", "003782", "003783", "003784", "003785", "003786", "003787", "003788", "003789", "003790", "003791", "003792", "003793", "003794", "003795", "003796", "003797", "003798", "003799", "003800", "003801", "003802", "003803", "003804", "003805", "003806", "003807", "003808", "003809", "003810", "003811", "003812", "003813", "003814", "003815", "003816", "003817", "003818", "003819", "003820", "003821", "003822", "003823", "003824", "003825", "003826", "003827", "003828", "003829", "003830", "003831", "003832", "003833", "003834", "003835", "003836", "003837", "003838", "003839", "003840", "003841", "003842", "003843", "003844", "003845", "003846", "003847", "003848", "003849", "003850", "003851", "003852", "003853", "003854", "003855", "003856", "003857", "003858", "003859", "003860", "004554", "004555", "004556", "004557", "004558", "004559", "004560", "004561", "004562", "004563", "004564", "004565", "004566", "004567", "004568", "004569", "004570", "004571", "004572", "004573", "004574", "004575", "004576", "004577", "004578", "004579", "004580", "004581", "004582", "004583", "004584", "004585", "004586", "004587", "004588", "004589", "004590", "004591", "004592", "004593", "004594", "004595", "004596", "004597", "004598", "004599", "004600", "004601", "004602", "004603", "004604", "004605", "004606", "004607", "004608", "004609", "004610", "004611", "004612", "004613", "004614", "004615", "004616", "004617", "004618", "004619", "004620", "004621", "004622", "004623", "004624", "004625", "004626", "004627", "004628", "004629", "004630", "004631", "004632", "004633", "004634", "004635", "004636", "004637", "004638", "004639", "004640", "004641", "004642", "004643", "004644", "004645", "004646", "004647", "004648", "004649", "004650", "004651", "004652", "004653", "004654", "004655", "004656", "004657", "004658", "004659", "004660", "004661", "004662", "004663", "004664", "004665", "004666", "004667", "004668", "004669", "004670", "004671", "004672", "004673", "004674", "004675", "004676", "004677", "004678", "004679", "004680", "004681", "004682", "004683", "004684", "004685", "004686", "004687", "004688", "004689", "004690", "004691", "004692", "004693", "004885", "004886", "004887", "004888", "004889", "004890", "004891", "004892", "004893", "004894", "004895", "004896", "004897", "004898", "004899", "004900", "004901", "004902", "004903", "004904", "004905", "004906", "004907", "004908", "004909", "004910", "004911", "004912", "004913", "004914", "004915", "004916", "004917", "004918", "004919", "004920", "004921", "004922", "004923", "004924", "004925", "004926", "004927", "004928", "004929", "004930", "004931", "004932", "004933", "004934", "004935", "004936", "004937", "004938", "004939", "004940", "004941", "004942", "004943", "004944", "004945", "004946", "004947", "004948", "004949", "004950", "004951", "004952", "004953", "004954", "004955", "004956", "004957", "004958", "004959", "004960", "004961", "004962", "004963", "004964", "004965", "004966", "004967", "004968", "004969", "004970", "004971", "004972", "004973", "004974", "004975", "004976", "004977", "004978", "004979", "004980", "004981", "004982", "004983", "004984", "004985", "004986", "004987", "004988", "004989", "004990", "004991", "004992", "004993", "004994", "004995", "004996", "004997", "004998", "004999", "005000", "005001", "005002", "005003", "005004", "005005", "005006", "005007", "005008", "005009", "005010", "005011", "005012", "005013", "005014", "005015", "005016", "005017", "005018", "005019", "005020", "005021", "005022", "005023", "005024", "005025", "005026", "005027", "005028", "005029", "005030", "005031", "005032", "005033", "005034", "005035", "005036", "005037", "005038", "005039", "005040", "005041", "005042", "005043", "005044", "005045", "005046", "005047", "005048", "005049", "005050", "005051", "005052", "005053", "005054", "005055", "005056", "005057", "005058", "005059", "005060", "005061", "005062", "005063", "005064", "005065", "005066", "005067", "005068", "005069", "005070", "005071", "005072", "005073", "005074", "005075", "005076", "005077", "005078", "005079", "005080", "005081", "005082", "005083", "005084", "005085", "005086", "005087", "005088", "005089", "005090", "005091", "005092", "005093", "005094", "005095", "005096", "005097", "005098", "005099", "005100", "005101", "005102", "005103", "005104", "005105", "005106", "005107", "005108", "005109", "005110", "005111", "005112", "005113", "005114", "005115", "005116", "005117", "005118", "005119", "005120", "005121", "005122", "005123", "005124", "005125", "005126", "005127", "005128", "005129", "005130", "005131", "005132", "005133", "005134", "005135", "005136", "005137", "005138", "005139", "005140", "005141", "005142", "005143", "005144", "005145", "005146", "005147", "005148", "005149", "005150", "005151", "005152", "005153", "005154", "005155", "005156", "005157", "005158", "005159", "005160", "005161", "005162", "005163", "005164", "005165", "005166", "005167", "005168", "005169", "005170", "005171", "005172", "005173", "005174", "005175", "005176", "005177", "005178", "005179", "005180", "005181", "005182", "005183", "005184", "005185", "005186", "005187", "005188", "005189", "005190", "005191", "005192", "005193", "005194", "005195", "005196", "005197", "005198", "005199", "005200", "005201", "005202", "005203", "005204", "005205", "005206", "005207", "005208", "005209", "005210", "005211", "005212", "005213", "005214", "005215", "005216", "005217", "005218", "005219", "005220", "005221", "005222", "005223", "005224", "005225", "005226", "005227", "005228", "005229", "005230", "005231", "005232", "005233", "005234", "005235", "005236", "005237", "005238", "005239", "005240", "005241", "005242", "005243", "005244", "005245", "005246", "005247", "005248", "005249", "005250", "005251", "005252", "005253", "005254", "005255", "005256", "005257", "005258", "005259", "005260", "005261", "005262", "005263", "005264", "005265", "005266", "005267", "005268", "005269", "005270", "005271", "005272", "005273", "005274", "005275", "005276", "005277", "005278", "005279", "005280", "005281", "005282", "005283", "005284", "005285", "005286", "005287", "005288", "005289", "005290", "005291", "005292", "005293", "005294", "005295", "005296", "005297", "005298", "005299", "005300", "005301", "005302", "005303", "005304", "005305", "005306", "005307", "005308", "005309", "005310", "005311", "005312", "005313", "005314", "005315", "005316", "005317", "005318", "005319", "005320", "005321", "005322", "005323", "005324", "005325", "005326", "005327", "005328", "005329", "005330", "005331", "005332", "005333", "005334", "005335", "005336", "005337", "005338", "005339", "005340", "005341", "005342", "005343", "005344", "005345", "005346", "005347", "005348", "005349", "005350", "005351", "005352", "005353", "005354", "005355", "005356", "005357", "005358", "005359", "005360", "005361", "005362", "005363", "005364", "005365", "005366", "005367", "005368", "005369", "005370", "005371", "005372", "005373", "005374", "005375", "005376", "005377", "005378", "005379", "005380", "005381", "005382", "005383", "005384", "005385", "005386", "005387", "005388", "005389", "005390", "005391", "005392", "005393", "005394", "005395", "005396", "005397", "005398", "005399", "005400", "005401", "005402", "005403", "005404", "005405", "005406", "005407", "005408", "005409", "005410", "005411", "005412", "005413", "005744", "005745", "005746", "005747", "005748", "005749", "005750", "005751", "005752", "005753", "005754", "005755", "005756", "005757", "005758", "005759", "005760", "005761", "005762", "005763", "005764", "005765", "005766", "005767", "005768", "005769", "005770", "005771", "005772", "005773", "005774", "005775", "005776", "005777", "005778", "005779", "005780", "005781", "005782", "005783", "005784", "005785", "005786", "005787", "005788", "005789", "005790", "005791", "005792", "005793", "005794", "005795", "005796", "005797", "005798", "005799", "005800", "005801", "005802", "005803", "005804", "005805", "005806", "005807", "005808", "005809", "005810", "005811", "005812", "005813", "005814", "005815", "005816", "005817", "005818", "005819", "005820", "005821", "005822", "005823", "005824", "005825", "005826", "005827", "005828", "005829", "005830", "005831", "005832", "005833", "005834", "005835", "005836", "005837", "005838", "005839", "005840", "005841", "005842", "005843", "005844", "005845", "005846", "005847", "005848", "005849", "005850", "005851", "005852", "005853", "005854", "005855", "005856", "005857", "005858", "005859", "005860", "005861", "005862", "005863", "005864", "005865", "005866", "005867", "005868", "005869", "005870", "005871", "005872", "005873", "005874", "005875", "005876", "005877", "005878", "005879", "005880", "005881", "005882", "005883", "005884", "005885", "005886", "005887", "005888", "005889", "005890", "005891", "005892", "005893", "005894", "005895", "005896", "005897", "005898", "005899", "005900", "005901", "005902", "005903", "005904", "005905", "005906", "005907", "005908", "005909", "005910", "005911", "005912", "005913", "005914", "005915", "005916", "006817", "006818", "006819", "006820", "006821", "006822", "006823", "006824", "006825", "006826", "006827", "006828", "006829", "006830", "006831", "006832", "006833", "006834", "006835", "006836", "006837", "006838", "006839", "006840", "006841", "006842", "006843", "006844", "006845", "006846", "006847", "006848", "006849", "006850", "006851", "006852", "006853", "006854", "006855", "006856", "006857", "006858", "006859", "006860", "006861", "006862", "006863", "006864", "006865", "006866", "006867", "006868", "006869", "006870", "006871", "006872", "006873", "006874", "006875", "006876", "006877", "006878", "006879", "006880", "006881", "006882", "006883", "006884", "006885", "006886", "006887", "006888", "006889", "006890", "006891", "006892", "006893", "006894", "006895", "006896", "006897", "006898", "006899", "006900", "006901", "006902", "006903", "006904", "006905", "006906", "006907", "006908", "006909", "006910", "006911", "006912", "006913", "006914", "006915", "006916", "006917", "006918", "006919", "006920", "006921", "006922", "006923", "006924", "006925", "006926", "006927", "006928", "006929", "006930", "006931", "006932", "006933", "006934", "006935", "006936", "006937", "006938", "006939", "006940", "006941", "006942", "006943", "006944", "006945", "006946", "006947", "006948", "006949", "006950", "006951", "006952", "006953", "006954", "006955", "006956", "006957", "006958", "006959", "006960", "006961", "006962", "006963", "006964", "006965", "006966", "006967", "006968", "006969", "006970", "006971", "006972", "006973", "006974", "006975", "006976", "006977", "006978", "006979", "006980", "006981", "006982", "006983", "006984", "006985", "006986", "006987", "006988", "006989", "006990", "006991", "006992", "006993", "006994", "006995", "006996", "006997", "006998", "006999", "007000", "007001", "007002", "007003", "007004", "007005", "007006", "007007", "007008", "007009", "007010", "007011", "007012", "007013", "007014", "007015", "007016", "007017", "007018", "007019", "007020", "007021", "007022", "007023", "007024", "007025", "007026", "007027", "007028", "007029", "007030", "007031", "007032", "007033", "007034", "007035", "007036", "007037", "007038", "007039", "007040", "007041", "007042", "007043", "007044", "007045", "007046", "007047", "007048", "007049", "007050", "007051", "007052", "007053", "007054", "007055", "007056", "007057", "007058", "007059", "007060", "007061", "007062", "007063", "007064", "007065", "007066", "007067", "007068", "007069", "007070", "007071", "007072", "007073", "007074", "007075", "007076", "007077", "007078", "007079", "007080", "007081", "007082", "007083", "007084", "007085", "007086", "007087", "007088", "007089", "007090", "007091", "007092", "007093", "007094", "007095", "007096", "007097", "007098", "007099", "007100", "007101", "007102", "007103", "007104", "007105", "007106", "007107", "007108", "007109", "007110", "007111", "007112", "007113", "007114", "007115", "007116", "007117", "007118", "007119", "007120", "007121", "007122", "007123", "007124", "007125", "007126", "007127", "007128", "007129", "007130", "007131", "007132", "007133", "007134", "007135", "007136", "007137", "007138", "007139", "007140", "007141", "007142", "007143", "007144", "007145", "007146", "007147", "007148", "007149", "007150", "007151", "007152", "007153", "007154", "007155", "007156", "007157", "007158", "007159", "007160", "007161", "007162", "007163", "007164", "007165", "007166", "007167", "007168", "007169", "007170", "007171", "007172", "007173", "007174", "007175", "007176", "007177", "007178", "007179", "007180", "007181", "007182", "007183", "007184", "007185", "007186", "007187", "007188", "007189", "007190", "007191", "007192", "007193", "007194", "007195", "007196", "007197", "007198", "007199", "007200", "007201", "007202", "007203", "007204", "007205", "007206", "007207", "007208", "007209", "007210", "007211", "007212", "007213", "007214", "007215", "007216", "007217", "007218", "007219", "007220", "007221", "007222", "007223", "007224", "007225", "007226", "007227", "007228", "007229", "007230", "007231", "007232", "007233", "007234", "007235", "007236", "007237", "007238", "007239", "007240", "007241", "007242", "007243", "007244", "007245", "007246", "007247", "007248", "007249", "007250", "007251", "007252", "007253", "007254", "007255", "007796", "007797", "007798", "007799", "007800", "007801", "007802", "007803", "007804", "007805", "007806", "007807", "007808", "007809", "007810", "007811", "007812", "007813", "007814", "007815", "007816", "007817", "007818", "007819", "007820", "007821", "007822", "007823", "007824", "007825", "007826", "007827", "007828", "007829", "007830", "007831", "007832", "007833", "007834", "007835", "007836", "007837", "007838", "007839", "007840", "007841", "007842", "007843", "007844", "007845", "007846", "007847", "007848", "007849", "007850", "007851", "007852", "007853", "007854", "007855", "007856", "007857", "007858", "007859", "007860", "007861", "007862", "007863", "007864", "007865", "007866", "007867", "007868", "007869", "007870", "007871", "007872", "007873", "007874", "007875", "007876", "007877", "007878", "007879", "007880", "007881", "007882", "007883", "007884", "007885", "007886", "007887", "007888", "007889", "007890", "007891", "007892", "007893", "007894", "007895", "007896", "007897", "007898", "007899", "007900", "007901", "007902", "007903", "007904", "007905", "007906", "007907", "007908", "007909", "007910", "007911", "007912", "007913", "007914", "007915", "007916", "007917", "007918", "007919", "007920", "007921", "007922", "007923", "007924", "007925", "007926", "007927", "007928", "007929", "007930", "007931", "007932", "007933", "007934", "007935", "007936", "007937", "007938", "007939", "007940", "007941", "007942", "007943", "007944", "007945", "007946", "007947", "007948", "007949", "007950", "007951", "007952", "007953", "007954", "007955", "007956", "007957", "007958", "007959", "007960", "007961", "007962", "007963", "007964", "007965", "007966", "007967", "007968", "007969", "007970", "007971", "007972", "007973", "007974", "007975", "007976", "007977", "007978", "007979", "007980", "007981", "007982", "007983", "007984", "007985", "007986", "007987", "007988", "007989", "007990", "007991", "007992", "007993", "007994", "007995", "007996", "007997", "007998", "007999", "008000", "008001", "008002", "008003", "008004", "008005", "008006", "008007", "008008", "008009", "008010", "008011", "008012", "008013", "008014", "008015", "008016", "008017", "008018", "008019", "008020", "008021", "008022", "008023", "008024", "008025", "008026", "008027", "008028", "008029", "008030", "008031", "008032", "008033", "008034", "008035", "008036", "008037", "008038", "008039", "008040", "008041", "008042", "008043", "008044", "008045", "008046", "008047", "008048", "008049", "008050", "008051", "008052", "008053", "008054", "008055", "008056", "008057", "008058", "008059", "008060", "008061", "008062", "008063", "008064", "008065", "008066", "008067", "008068", "008069", "008070", "008071", "008072", "008073", "008074", "008075", "008076", "008077", "008078", "008079", "008080", "008081", "008082", "008083", "008084", "008085", "008086", "008087", "008088", "008089", "008090", "008091", "008092", "008093", "008094", "008095", "008096", "008097", "008098", "008099", "008100", "008101", "008102", "008103", "008104", "008105", "008106", "008107", "008108", "008109", "008110", "008111", "008112", "008113", "008114", "008115", "008116", "008117", "008118", "008119", "008120", "008121", "008122", "008123", "008124", "008125", "008126", "008127", "008128", "008129", "008130", "008131", "008132", "008133", "008134", "008135", "008136", "008137", "008138", "008139", "008140", "008141", "008142", "008143", "008144", "008145", "008146", "008147", "008148", "008149", "008150", "008151", "008152", "008153", "008154", "008155", "008156", "008157", "008158", "008159", "008160", "008161", "008162", "008163", "008164", "008165", "008166", "008167", "008168", "008169", "008170", "008171", "008172", "008173", "008174", "008175", "008176", "008177", "008178", "008179", "008180", "008181", "008182", "008183", "008184", "008185", "008186", "008187", "008188", "008189", "008190", "008191", "008192", "008193", "008194", "008195", "008196", "008197", "008198", "008199", "008200", "008201", "008202", "008203", "008204", "008205", "008206", "008207", "008208", "008209", "008210", "008211", "008212", "008213", "008214", "008215", "008216", "008217", "008218", "008219", "008220", "008221", "008222", "008223", "008224", "008225", "008226", "008227", "008228", "008229", "008230", "008231", "008232", "008233", "008234", "008235", "008236", "008237", "008238", "008239", "008240", "008241", "008242", "008243", "008244", "008245", "008246", "008247", "008248", "008249", "008250", "008251", "008252", "008253", "008254", "008255", "008256", "008257", "008258", "008259", "008260", "008261", "008262", "008263", "008264", "008265", "008266", "008267", "008268", "008269", "008270", "008271", "008272", "008273", "008274", "008275", "008276", "008277", "008278", "008279", "008280", "008281", "008282", "008283", "008284", "008285", "008286", "008287", "008288", "008289", "008290", "008291", "008292", "008293", "008294", "008295", "008296", "008297", "008298", "008299", "008300", "008301", "008302", "008303", "008304", "008305", "008306", "008307", "008308", "008309", "008310", "008311", "008312", "008313", "008314", "008315", "008316", "008317", "008318", "008319", "008320", "008321", "008322", "008323", "008324", "008325", "008326", "008327", "008328", "008329", "008330", "008331", "008332", "008333", "008334", "008335", "008336", "008337", "008338", "008339", "008340", "008341", "008342", "008343", "008344", "008345", "008346", "008347", "008348", "008349", "008350", "008351", "008352", "008353", "008354", "008355", "008356", "008357", "008358", "008359", "008360", "008361", "008362", "008363", "008364", "008365", "008366", "008367", "008368", "008369", "008370", "008371", "008372", "008373", "008374", "008375", "008376", "008377", "008378", "008379", "008380", "008381", "008382", "008383", "008384", "008385", "008386", "008387", "008388", "008389", "008390", "008391", "008392", "008393", "008394", "008395", "008396", "008397", "008398", "008399", "008400", "008401", "008402", "008403", "008404", "008405", "008406", "008407", "008408", "008409", "008410", "008411", "008412", "008413", "008414", "008415", "008416", "008417", "008418", "008419", "008420", "008421", "008422", "008423", "008424", "008425", "008426", "008427", "008428", "008429", "008430", "008431", "008432", "008433", "008434", "008435", "008436", "008437", "008438", "008439", "008440", "008441", "008442", "008443", "008444", "008445", "008446", "008447", "008448", "008449", "008450", "008451", "008452", "008453", "008454", "008455", "008456", "008457", "008458", "008459", "008460", "008461", "008462", "008463", "008464", "008465", "008466", "008467", "008468", "008469", "008470", "008471", "008472", "008473", "008474", "008475", "009151", "009152", "009153", "009154", "009155", "009156", "009157", "009158", "009159", "009160", "009161", "009162", "009163", "009164", "009165", "009166", "009167", "009168", "009169", "009170", "009171", "009172", "009173", "009174", "009175", "009176", "009177", "009178", "009179", "009180", "009181", "009182", "009183", "009184", "009185", "009186", "009187", "009188", "009189", "009190", "009191", "009192", "009193", "009194", "009195", "009196", "009197", "009198", "009199", "009200", "009201", "009202", "009203", "009204", "009205", "009206", "009207", "009208", "009209", "009210", "009211", "009212", "009213", "009214", "009215", "009216", "009217", "009218", "009219", "009220", "009221", "009222", "009223", "009224", "009225", "009226", "009227", "009228", "009229", "009230", "009231", "009232", "009233", "009234", "009235", "009236", "009237", "009238", "009239", "009240", "009241", "009242", "009243", "009244", "009245", "009246", "009247", "009248", "009249", "009250", "009251", "009252", "009253", "009254", "009255", "009256", "009257", "009258", "009259", "009260", "009261", "009262", "009263", "009264", "009265", "009266", "009267", "009268", "009269", "009270", "009271", "009272", "009273", "009274", "009275", "009276", "009277", "009278", "009279", "009280", "009281", "009282", "009283", "009284", "009285", "009286", "009287", "009288", "009289", "009290", "009291", "009292", "009293", "009294", "009295", "009296", "009297", "009298", "009299", "009300", "009301", "009302", "009303", "009304", "009305", "009306", "009307", "009308", "009309", "009310", "009311", "009312", "009313", "009314", "009315", "009316", "009317", "009318", "009319", "009320", "009321", "009322", "009323", "009324", "009325", "009326", "009327", "009328", "009329", "009330", "009331", "009332", "009333", "009334", "009335", "009336", "009337", "009338", "009339", "009340", "009341", "009342", "009343", "009344", "009345", "009346", "009347", "009348", "009349", "009350", "009351", "009352", "009353", "009354", "009355", "009356", "009357", "009358", "009359", "009360", "009501", "009502", "009503", "009504", "009505", "009506", "009507", "009508", "009509", "009510", "009511", "009512", "009513", "009514", "009515", "009516", "009517", "009518", "009519", "009520", "009521", "009522", "009523", "009524", "009525", "009526", "009527", "009528", "009529", "009530", "009531", "009532", "009533", "009534", "009535", "009536", "009537", "009538", "009539", "009540", "009541", "009542", "009543", "009544", "009545", "009546", "009547", "009548", "009549", "009550", "009551", "009552", "009553", "009554", "009555", "009556", "009557", "009558", "009559", "009560", "009561", "009562", "009563", "009564", "009565", "009566", "009567", "009568", "009569", "009570", "009571", "009572", "009573", "009574", "009575", "009576", "009577", "009578", "009579", "009580", "009581", "009582", "009583", "009584", "009585", "009586", "009587", "009588", "009589", "009590", "009591", "009592", "009593", "009594", "009595", "009596", "009597", "009598", "009599", "009600", "009601", "009602", "009603", "009604", "009605", "009606", "009607", "009608", "009609", "009610", "009611", "009612", "009613", "009614", "009615", "009616", "009617", "009618", "009619", "009620", "009621", "009622", "009623", "009624", "009625", "009626", "009627", "009628", "009629", "009630", "009631", "009632", "009633", "009634", "009635", "009636", "009637", "009638", "009639", "009640", "009641", "009642", "009643", "009644", "009645", "009646", "009647", "009648", "009649", "009650", "009651", "009652", "009653", "009654", "009655", "009656", "009657", "009658", "009659", "009660", "009661", "009662", "009663", "009664", "009665", "009666", "009667", "009668", "009669", "009670", "009671", "009672", "009673", "009674", "009675", "009676", "009677", "009678", "009679", "009680", "009681", "009682", "009683", "009684", "009685", "009686", "009687", "009688", "009689", "009690", "011641", "011642", "011643", "011644", "011645", "011646", "011647", "011648", "011649", "011650", "011651", "011652", "011653", "011654", "011655", "011656", "011657", "011658", "011659", "011660", "011661", "011662", "011663", "011664", "011665", "011666", "011667", "011668", "011669", "011670", "011671", "011672", "011673", "011674", "011675", "011676", "011677", "011678", "011679", "011680", "011681", "011682", "011683", "011684", "011685", "011686", "011687", "011688", "011689", "011690", "011691", "011692", "011693", "011694", "011695", "011696", "011697", "011698", "011699", "011700", "011701", "011702", "011703", "011704", "011705", "011706", "011707", "011708", "011709", "011710", "011711", "011712", "011713", "011714", "011715", "011716", "011717", "011718", "011719", "011720", "011721", "011722", "011723", "011724", "011725", "011726", "011727", "011728", "011729", "011730", "011731", "011732", "011733", "011734", "011735", "011736", "011737", "011738", "011739", "011740", "011741", "011742", "011743", "011744", "011745", "011746", "011747", "011748", "011749", "011750", "011751", "011752", "011753", "011754", "011755", "011756", "011757", "011758", "011759", "011760", "011761", "011762", "011763", "011764", "011765", "011766", "011767", "011768", "011769", "011770", "011771", "011772", "011773", "011774", "011775", "011776", "011777", "011778", "011779", "011780", "011781", "011782", "011783", "011784", "011785", "011786", "011787", "011788", "011789", "011790", "011791", "011792", "011793", "011794", "011795", "011796", "011797", "011798", "011799", "011800", "011801", "011802", "011803", "011804", "011805", "011806", "011807", "011808", "011809", "011810", "011811", "011812", "011813", "011814", "011815", "011816", "011817", "011818", "011819", "011820", "011821", "011822", "011823", "011824", "011825", "011826", "011827", "011828", "011829", "011830", "011831", "011832", "011833", "011834", "011835", "011836", "011837", "011838", "011839", "011840", "011841", "011842", "011843", "011844", "011845", "011846", "011847", "011848", "011849", "011850", "011851", "011852", "011853", "011854", "011855", "011856", "011857", "011858", "011859", "011860", "011861", "011862", "011863", "011864", "011865", "011866", "011867", "011868", "011869", "011870", "011871", "011872", "011873", "011874", "011875", "011876", "011877", "011878", "011879", "011880", "011881", "011882", "011883", "011884", "011885", "011886", "011887", "011888", "011889", "011890", "011891", "011892", "011893", "011894", "011895", "011896", "011897", "011898", "011899", "011900", "011901", "011902", "011903", "011904", "011905", "011906", "011907", "011908", "011909", "011910", "011911", "011912", "011913", "011914", "011915", "011916", "011917", "011918", "011919", "011920", "011921", "011922", "011923", "011924", "011925", "011926", "011927", "011928", "011929", "011930", "011931", "011932", "011933", "011934", "011935", "011936", "011937", "011938", "011939", "011940", "011941", "011942", "011943", "011944", "011945", "011946", "011947", "011948", "011949", "011950", "011951", "011952", "011953", "011954", "011955", "011956", "011957", "011958", "011959", "011960", "011961", "011962", "011963", "011964", "011965", "011966", "011967", "011968", "011969", "011970", "011971", "011972", "011973", "011974", "011975", "011976", "011977", "011978", "011979", "011980", "011981", "011982", "011983", "011984", "011985", "011986", "011987", "011988", "011989", "011990", "011991", "011992", "011993", "011994", "011995", "011996", "011997", "011998", "011999", "012000", "012001", "012002", "012003", "012004", "012005", "012006", "012007", "012008", "012009", "012010", "012011", "012012", "012013", "012014", "012015", "012016", "012017", "012018", "012019", "012020", "012021", "012022", "012023", "012024", "012025", "012026", "012027", "012028", "012029", "012030", "012031", "012032", "012033", "012034", "012035", "012036", "012037", "012038", "012039", "012040", "012041", "012042", "012043", "012044", "012045", "012046", "012047", "012048", "012049", "012050", "012051", "012052", "012053", "012054", "012055", "012056", "012057", "012058", "012059", "012060", "012061", "012062", "012063", "012064", "012065", "012066", "012067", "012068", "012069", "012070", "012071", "012072", "012073", "012074", "012075", "012076", "012077", "012078", "012079", "012080", "012081", "012082", "012083", "012084", "012085", "012086", "012087", "012088", "012089", "012090", "012291", "012292", "012293", "012294", "012295", "012296", "012297", "012298", "012299", "012300", "012301", "012302", "012303", "012304", "012305", "012306", "012307", "012308", "012309", "012310", "012311", "012312", "012313", "012314", "012315", "012316", "012317", "012318", "012319", "012320", "012321", "012322", "012323", "012324", "012325", "012326", "012327", "012328", "012329", "012330", "012331", "012332", "012333", "012334", "012335", "012336", "012337", "012338", "012339", "012340", "012341", "012342", "012343", "012344", "012345", "012346", "012347", "012348", "012349", "012350", "012351", "012352", "012353", "012354", "012355", "012356", "012357", "012358", "012359", "012360", "012361", "012362", "012363", "012364", "012365", "012366", "012367", "012368", "012369", "012370", "012371", "012372", "012373", "012374", "012375", "012376", "012377", "012378", "012379", "012380", "012381", "012382", "012383", "012384", "012385", "012386", "012387", "012388", "012389", "012390", "012391", "012392", "012393", "012394", "012395", "012396", "012397", "012398", "012399", "012400", "012401", "012402", "012403", "012404", "012405", "012406", "012407", "012408", "012409", "012410", "012411", "012412", "012413", "012414", "012415", "012416", "012417", "012418", "012419", "012420", "012421", "012422", "012423", "012424", "012425", "012426", "012427", "012428", "012429", "012430", "012431", "012432", "012433", "012434", "012435", "012436", "012437", "012438", "012439", "012440", "012441", "012442", "012443", "012444", "012445", "012446", "012447", "012448", "012449", "012450", "012451", "012452", "012453", "012454", "012455", "012456", "012457", "012458", "012459", "012460", "012461", "012462", "012463", "012464", "012465", "012466", "012467", "012468", "012469", "012470", "012471", "012472", "012473", "012474", "012475", "012476", "012477", "012478", "012479", "012480", "012481", "012482", "012483", "012484", "012485", "012486", "012487", "012488", "012489", "012490", "012491", "012492", "012493", "012494", "012495", "012496", "012497", "012498", "012499", "012500", "012501", "012502", "012503", "012504", "012505", "012506", "012507", "012508", "012509", "012510", "012811", "012812", "012813", "012814", "012815", "012816", "012817", "012818", "012819", "012820", "012821", "012822", "012823", "012824", "012825", "012826", "012827", "012828", "012829", "012830", "012831", "012832", "012833", "012834", "012835", "012836", "012837", "012838", "012839", "012840", "012841", "012842", "012843", "012844", "012845", "012846", "012847", "012848", "012849", "012850", "012851", "012852", "012853", "012854", "012855", "012856", "012857", "012858", "012859", "012860", "012861", "012862", "012863", "012864", "012865", "012866", "012867", "012868", "012869", "012870", "012871", "012872", "012873", "012874", "012875", "012876", "012877", "012878", "012879", "012880", "012881", "012882", "012883", "012884", "012885", "012886", "012887", "012888", "012889", "012890", "012891", "012892", "012893", "012894", "012895", "012896", "012897", "012898", "012899", "012900", "012901", "012902", "012903", "012904", "012905", "012906", "012907", "012908", "012909", "012910", "012911", "012912", "012913", "012914", "012915", "012916", "012917", "012918", "012919", "012920", "012921", "012922", "012923", "012924", "012925", "012926", "012927", "012928", "012929", "012930", "012931", "012932", "012933", "012934", "012935", "012936", "012937", "012938", "012939", "012940", "012941", "012942", "012943", "012944", "012945", "012946", "012947", "012948", "012949", "012950", "012951", "012952", "012953", "012954", "012955", "012956", "012957", "012958", "012959", "012960", "012961", "012962", "012963", "012964", "012965", "012966", "012967", "012968", "012969", "012970", "012971", "012972", "012973", "012974", "012975", "012976", "012977", "012978", "012979", "012980", "012981", "012982", "012983", "012984", "012985", "012986", "012987", "012988", "012989", "012990", "012991", "012992", "012993", "012994", "012995", "012996", "012997", "012998", "012999", "013000", "013890", "013891", "013892", "013893", "013894", "013895", "013896", "013897", "013898", "013899", "013900", "013901", "013902", "013903", "013904", "013905", "013906", "013907", "013908", "013909", "013910", "013911", "013912", "013913", "013914", "013915", "013916", "013917", "013918", "013919", "013920", "013921", "013922", "013923", "013924", "013925", "013926", "013927", "013928", "013929", "013930", "013931", "013932", "013933", "013934", "013935", "013936", "013937", "014038", "014039", "014040", "014041", "014042", "014043", "014044", "014045", "014046", "014047", "014048", "014049", "014050", "014051", "014052", "014053", "014054", "014055", "014056", "014057", "014058", "014059", "014060", "014061", "014062", "014063", "014064", "014065", "014066", "014067", "014068", "014069", "014070", "014071", "014072", "014073", "014074", "014075", "014076", "014077", "014078", "014079", "014080", "014081", "014082", "014083", "014084", "014085", "014086", "014087", "014088", "014089", "014090", "014091", "014092", "014093", "014094", "014095", "014096", "014097", "014098", "014099", "014100", "014101", "014102", "014103", "014104", "014105", "014106", "014107", "014108", "014109", "014110", "014111", "014112", "014113", "014114", "014115", "014116", "014117", "014118", "014119", "014120", "014121", "014122", "014123", "014124", "014125", "014126", "014127", "014128", "014129", "014130", "014131", "014132", "014133", "014134", "014135", "014136", "014137", "014138", "014139", "014140", "014141", "014142", "014143", "014144", "014145", "014146", "014147", "014148", "014149", "014150", "014151", "014152", "014153", "014154", "014155", "014156", "014157", "015138", "015139", "015140", "015141", "015142", "015143", "015144", "015145", "015146", "015147", "015148", "015149", "015150", "015151", "015152", "015153", "015154", "015155", "015156", "015157", "015158", "015159", "015160", "015161", "015162", "015163", "015164", "015165", "015166", "015167", "015168", "015169", "015170", "015171", "015172", "015173", "015174", "015175", "015176", "015177", "015178", "015179", "015180", "015181", "015182", "015183", "015184", "015185", "015186", "015187", "015188", "015189", "015190", "015191", "015192", "015193", "015194", "015195", "015196", "015197", "015198", "015199", "015200", "015201", "015202", "015203", "015204", "015205", "015206", "015207", "015208", "015209", "015210", "015211", "015212", "015213", "015214", "015215", "015216", "015217", "015218", "015219", "015220", "015221", "015222", "015223", "015224", "015225", "015226", "015227", "015228", "015229", "015230", "015231", "015232", "015233", "015234", "015235", "015236", "015237", "015238", "015239", "015240", "015241", "015242", "015243", "015244", "015245", "015246", "015247", "015248", "015249", "015250", "015251", "015252", "015253", "015254", "015255", "015256", "015257", "015258", "015259", "015260", "015261", "015262", "015263", "015264", "015265", "015266", "015267", "015268", "015269", "015270", "015271", "015272", "015273", "015274", "015275", "015276", "015277", "015278", "015279", "015280", "015281", "015282", "015283", "015284", "015285", "015286", "015287", "015288", "015289", "015290", "015291", "015292", "015293", "015294", "015295", "015296", "015297", "016268", "016269", "016270", "016271", "016272", "016273", "016274", "016275", "016276", "016277", "016278", "016279", "016280", "016281", "016282", "016283", "016284", "016285", "016286", "016287", "016288", "016289", "016290", "016291", "016292", "016293", "016294", "016295", "016296", "016297", "016298", "016299", "016300", "016301", "016302", "016303", "016304", "016305", "016306", "016307", "016308", "016309", "016310", "016311", "016312", "016313", "016314", "016315", "016316", "016317", "016318", "016319", "016320", "016321", "016322", "016323", "016324", "016325", "016326", "016327", "016328", "016329", "016330", "016331", "016332", "016333", "016334", "016335", "016336", "016337", "016338", "016339", "016340", "016341", "016342", "016343", "016344", "016345", "016346", "016347", "016348", "016349", "016350", "016351", "016352", "016353", "016354", "016355", "016356", "016357", "016358", "016359", "016360", "016361", "016362", "016363", "016364", "016365", "016366", "016367", "016368", "016369", "016370", "016371", "016372", "016373", "016374", "016375", "016376", "016377", "016378", "016379", "016380", "016381", "016382", "016383", "016384", "016385", "016386", "016387", "016388", "016389", "016390", "016391", "016392", "016393", "016394", "016395", "016396", "016397", "016398", "016399", "016400", "016401", "016402", "016403", "016404", "016405", "016406", "016407", "016408", "016409", "016410", "016411", "016412", "016413", "016414", "016415", "016416", "016417", "016418", "016419", "016420", "016421", "016422", "016423", "016424", "016425", "016426", "016427", "016428", "016429", "016430", "016431", "016432", "016433", "016434", "016435", "016436", "016437", "016438", "016439", "016440", "016441", "016442", "016443", "016444", "016445", "016446", "016447", "016448", "016449", "016450", "016451", "016452", "016453", "016454", "016455", "016456", "016457", "016458", "016459", "016460", "016461", "016462", "016463", "016464", "016465", "016466", "016467", "016468", "016469", "016470", "016471", "016472", "016473", "016474", "016475", "016476", "016477", "016478", "016479", "016480", "016481", "016482", "016483", "016484", "016485", "016486", "016487", "016488", "016489", "016490", "016491", "016492", "016493", "016494", "016495", "016496", "016497", "016498", "016499", "016500", "016501", "016502", "016503", "016504", "016505", "016506", "016507", "016508", "016509", "016510", "016511", "016512", "016513", "016514", "016515", "016516", "016517", "016518", "016519", "016520", "016521", "016522", "016523", "016524", "016525", "016526", "016527", "016528", "016529", "016530", "016531", "016532", "016533", "016534", "016535", "016536", "016537", "016538", "016539", "016540", "016541", "016542", "016543", "016544", "016545", "016546", "016547", "016548", "016549", "016550", "016551", "016552", "016553", "016554", "016555", "016556", "016557", "016558", "016559", "016560", "016561", "016562", "016563", "016564", "016565", "016566", "016567", "016568", "016569", "016570", "016571", "016572", "016573", "016574", "016575", "016576", "016577", "016578", "016579", "016580", "016581", "016582", "016583", "016584", "016585", "016586", "016587", "016588", "016589", "016590", "016591", "016592", "016593", "016594", "016595", "016596", "016597", "016598", "016599", "016600", "016601", "016602", "016603", "016604", "016605", "016606", "016607", "016608", "016609", "016610", "016611", "016612", "016613", "016614", "016615", "016616", "016617", "016618", "016619", "016620", "016621", "016622", "016623", "016624", "016625", "016626", "016627", "016628", "016629", "016630", "016631", "016632", "016633", "016634", "016635", "016636", "016637", "016638", "016639", "016640", "016641", "016642", "016643", "016644", "016645", "016646", "016647", "016648", "016649", "016650", "016651", "016652", "016653", "016654", "016655", "016656", "016657", "016658", "016659", "016660", "016661", "016662", "016663", "016664", "016665", "016666", "016667", "016668", "016669", "016670", "016671", "016672", "016673", "016674", "016675", "016676", "016677", "016678", "016679", "016680", "016681", "016682", "016683", "016684", "016685", "016686", "016687", "016688", "016689", "016690", "016691", "016692", "016693", "016694", "016695", "016696", "016697"], "test_A": ["002065", "002066", "002067", "002068", "002069", "002070", "002071", "002072", "002073", "002074", "002075", "002076", "002077", "002078", "002079", "002080", "002081", "002082", "002083", "002084", "002085", "002086", "002087", "002088", "002089", "002090", "002091", "002092", "002093", "002094", "002095", "002096", "002097", "002098", "002099", "002100", "002101", "002102", "002103", "002104", "002105", "002106", "002107", "002108", "002109", "002110", "002111", "002112", "002113", "002114", "002115", "002116", "002117", "002118", "002119", "002120", "002121", "002122", "002123", "002124", "002125", "002126", "002127", "002128", "002129", "002130", "002131", "002132", "002133", "002134", "002135", "002136", "002137", "002138", "002139", "002140", "002141", "002142", "002143", "002144", "002145", "002146", "002147", "002148", "002149", "002150", "002151", "002152", "002153", "002154", "002155", "002156", "002157", "002158", "002159", "002160", "002161", "002162", "002163", "002164", "002165", "002166", "002167", "002168", "002169", "002170", "002171", "002172", "002173", "002174", "002175", "002176", "002177", "002178", "002179", "002180", "002181", "002182", "002183", "002184", "002185", "002186", "002187", "002188", "002189", "002190", "002191", "002192", "002193", "002194", "002195", "002196", "002197", "002198", "002199", "002200", "002201", "002202", "002203", "002204", "002205", "002206", "002207", "002208", "002209", "002210", "002211", "002212", "002213", "002214", "002215", "002216", "002217", "002218", "002219", "002220", "002221", "002222", "002223", "002224", "002225", "002226", "002227", "002228", "002229", "002230", "002231", "002232", "002233", "002234", "002235", "002236", "002237", "002238", "002239", "002240", "002241", "002242", "002243", "002693", "002694", "002695", "002696", "002697", "002698", "002699", "002700", "002701", "002702", "002703", "002704", "002705", "002706", "002707", "002708", "002709", "002710", "002711", "002712", "002713", "002714", "002715", "002716", "002717", "002718", "002719", "002720", "002721", "002722", "002723", "002724", "002725", "002726", "002727", "002728", "002729", "002730", "002731", "002732", "002733", "002734", "002735", "002736", "002737", "002738", "002739", "002740", "002741", "002742", "002743", "002744", "002745", "002746", "002747", "002748", "002749", "002750", "002751", "002752", "002753", "002754", "002755", "002756", "002757", "002758", "002759", "002760", "002761", "002762", "002763", "002764", "002765", "002766", "002767", "002768", "002769", "002770", "002771", "002772", "002773", "002774", "002775", "002776", "002777", "002778", "002779", "002780", "002781", "002782", "002783", "002784", "002785", "002786", "002787", "002788", "002789", "002790", "002791", "002792", "002793", "002794", "002795", "002796", "002797", "002798", "002799", "002800", "002801", "002802", "002803", "002804", "002805", "002806", "002807", "002808", "002809", "002810", "002811", "002812", "002813", "002814", "002815", "002816", "002817", "002818", "002819", "002820", "002821", "002822", "002823", "002824", "002825", "002826", "002827", "002828", "002829", "002830", "002831", "002832", "002833", "002834", "002835", "002836", "002837", "002838", "002839", "002840", "002841", "002842", "002843", "002844", "002845", "002846", "002847", "002848", "002849", "002850", "002851", "002852", "002853", "002854", "002855", "002856", "002857", "002858", "002859", "002860", "002861", "004885", "004886", "004887", "004888", "004889", "004890", "004891", "004892", "004893", "004894", "004895", "004896", "004897", "004898", "004899", "004900", "004901", "004902", "004903", "004904", "004905", "004906", "004907", "004908", "004909", "004910", "004911", "004912", "004913", "004914", "004915", "004916", "004917", "004918", "004919", "004920", "004921", "004922", "004923", "004924", "004925", "004926", "004927", "004928", "004929", "004930", "004931", "004932", "004933", "004934", "004935", "004936", "004937", "004938", "004939", "004940", "004941", "004942", "004943", "004944", "004945", "004946", "004947", "004948", "004949", "004950", "004951", "004952", "004953", "004954", "004955", "004956", "004957", "004958", "004959", "004960", "004961", "004962", "004963", "004964", "004965", "004966", "004967", "004968", "004969", "004970", "004971", "004972", "004973", "004974", "004975", "004976", "004977", "004978", "004979", "004980", "004981", "004982", "004983", "004984", "004985", "004986", "004987", "004988", "004989", "004990", "004991", "004992", "004993", "004994", "004995", "004996", "004997", "004998", "004999", "005000", "005001", "005002", "005003", "005004", "005005", "005006", "005007", "005008", "005009", "005010", "005011", "005012", "005013", "005014", "005015", "005016", "005017", "005018", "005019", "005020", "005021", "005022", "005023", "005024", "005025", "005026", "005027", "005028", "005029", "005030", "005031", "005032", "005033", "005034", "005035", "005036", "005037", "005038", "005039", "005040", "005041", "005042", "005043", "005044", "005045", "005046", "005047", "005048", "005049", "005050", "005051", "005052", "005053", "005054", "005055", "005056", "005057", "005058", "005059", "005060", "005061", "005062", "005063", "006817", "006818", "006819", "006820", "006821", "006822", "006823", "006824", "006825", "006826", "006827", "006828", "006829", "006830", "006831", "006832", "006833", "006834", "006835", "006836", "006837", "006838", "006839", "006840", "006841", "006842", "006843", "006844", "006845", "006846", "006847", "006848", "006849", "006850", "006851", "006852", "006853", "006854", "006855", "006856", "006857", "006858", "006859", "006860", "006861", "006862", "006863", "006864", "006865", "006866", "006867", "006868", "006869", "006870", "006871", "006872", "006873", "006874", "006875", "006876", "006877", "006878", "006879", "006880", "006881", "006882", "006883", "006884", "006885", "006886", "006887", "006888", "006889", "006890", "006891", "006892", "006893", "006894", "006895", "006896", "006897", "006898", "006899", "006900", "006901", "006902", "006903", "006904", "006905", "006906", "006907", "006908", "006909", "006910", "006911", "006912", "006913", "006914", "006915", "006916", "006917", "006918", "006919", "006920", "006921", "006922", "006923", "006924", "006925", "006926", "006927", "006928", "006929", "006930", "006931", "006932", "006933", "006934", "006935", "006936", "006937", "006938", "006939", "006940", "006941", "006942", "006943", "006944", "006945", "006946", "006947", "006948", "006949", "006950", "006951", "006952", "006953", "006954", "006955", "006956", "006957", "006958", "006959", "006960", "006961", "006962", "006963", "006964", "006965", "006966", "006967", "006968", "006969", "006970", "006971", "006972", "006973", "006974", "006975", "006976", "006977", "006978", "006979", "006980", "006981", "006982", "006983", "006984", "006985", "006986", "006987", "006988", "006989", "006990", "006991", "006992", "006993", "006994", "006995", "006996", "006997", "006998", "006999", "007000", "007001", "007002", "007003", "007004", "007005", "007966", "007967", "007968", "007969", "007970", "007971", "007972", "007973", "007974", "007975", "007976", "007977", "007978", "007979", "007980", "007981", "007982", "007983", "007984", "007985", "007986", "007987", "007988", "007989", "007990", "007991", "007992", "007993", "007994", "007995", "007996", "007997", "007998", "007999", "008000", "008001", "008002", "008003", "008004", "008005", "008006", "008007", "008008", "008009", "008010", "008011", "008012", "008013", "008014", "008015", "008016", "008017", "008018", "008019", "008020", "008021", "008022", "008023", "008024", "008025", "008026", "008027", "008028", "008029", "008030", "008031", "008032", "008033", "008034", "008035", "008036", "008037", "008038", "008039", "008040", "008041", "008042", "008043", "008044", "008045", "008046", "008047", "008048", "008049", "008050", "008051", "008052", "008053", "008054", "008055", "008056", "008057", "008058", "008059", "008060", "008061", "008062", "008063", "008064", "008065", "008066", "008067", "008068", "008069", "008070", "008071", "008072", "008073", "008074", "008075", "008076", "008077", "008078", "008079", "008080", "008081", "008082", "008083", "008084", "008085", "012291", "012292", "012293", "012294", "012295", "012296", "012297", "012298", "012299", "012300", "012301", "012302", "012303", "012304", "012305", "012306", "012307", "012308", "012309", "012310", "012311", "012312", "012313", "012314", "012315", "012316", "012317", "012318", "012319", "012320", "012321", "012322", "012323", "012324", "012325", "012326", "012327", "012328", "012329", "012330", "012331", "012332", "012333", "012334", "012335", "012336", "012337", "012338", "012339", "012340", "012341", "012342", "012343", "012344", "012345", "012346", "012347", "012348", "012349", "012350", "012351", "012352", "012353", "012354", "012355", "012356", "012357", "012358", "012359", "012360", "012361", "012362", "012363", "012364", "012365", "012366", "012367", "012368", "012369", "012370", "012371", "012372", "012373", "012374", "012375", "012376", "012377", "012378", "012379", "012380", "012381", "012382", "012383", "012384", "012385", "012386", "012387", "012388", "012389", "012390", "012391", "012392", "012393", "012394", "012395", "012396", "012397", "012398", "012399", "012400", "012401", "012402", "012403", "012404", "012405", "012406", "012407", "012408", "012409", "012410", "012411", "012412", "012413", "012414", "012415", "012416", "012417", "012418", "012419", "012420", "012421", "012422", "012423", "012424", "012425", "012426", "012427", "012428", "012429", "012430", "012431", "012432", "012433", "012434", "012435", "012436", "012437", "012438", "012439", "012440", "012441", "012442", "012443", "012444", "012445", "012446", "012447", "012448", "012449", "012450", "012451", "012452", "012453", "012454", "012455", "012456", "012457", "012458", "012459", "012460", "012461", "012462", "012463", "012464", "012465", "012466", "012467", "012468", "012469", "012470", "012471", "012472", "012473", "012474", "012475", "012476", "012477", "012478", "012479", "012480", "012481", "012482", "012483", "012484", "012485", "012486", "012487", "012488", "012489", "012490", "012491", "012492", "012493", "012494", "012495", "012496", "012497", "012498", "012499", "012500", "012501", "012502", "012503", "012504", "012505", "012506", "012507", "012508", "012509", "012510", "014038", "014039", "014040", "014041", "014042", "014043", "014044", "014045", "014046", "014047", "014048", "014049", "014050", "014051", "014052", "014053", "014054", "014055", "014056", "014057", "014058", "014059", "014060", "014061", "014062", "014063", "014064", "014065", "014066", "014067", "014068", "014069", "014070", "014071", "014072", "014073", "014074", "014075", "014076", "014077", "014078", "014079", "014080", "014081", "014082", "014083", "014084", "014085", "014086", "014087", "014088", "014089", "014090", "014091", "014092", "014093", "014094", "014095", "014096", "014097", "014098", "014099", "014100", "014101", "014102", "014103", "014104", "014105", "014106", "014107", "014108", "014109", "014110", "014111", "014112", "014113", "014114", "014115", "014116", "014117", "014118", "014119", "014120", "014121", "014122", "014123", "014124", "014125", "014126", "014127", "014128", "014129", "014130", "014131", "014132", "014133", "014134", "014135", "014136", "014137", "014138", "014139", "014140", "014141", "014142", "014143", "014144", "014145", "014146", "014147", "014148", "014149", "014150", "014151", "014152", "014153", "014154", "014155", "014156", "014157", "016508", "016509", "016510", "016511", "016512", "016513", "016514", "016515", "016516", "016517", "016518", "016519", "016520", "016521", "016522", "016523", "016524", "016525", "016526", "016527", "016528", "016529", "016530", "016531", "016532", "016533", "016534", "016535", "016536", "016537", "016538", "016539", "016540", "016541", "016542", "016543", "016544", "016545", "016546", "016547", "016548", "016549", "016550", "016551", "016552", "016553", "016554", "016555", "016556", "016557", "016558", "016559", "016560", "016561", "016562", "016563", "016564", "016565", "016566", "016567", "016568", "016569", "016570", "016571", "016572", "016573", "016574", "016575", "016576", "016577", "016578", "016579", "016580", "016581", "016582", "016583", "016584", "016585", "016586", "016587", "016588", "016589", "016590", "016591", "016592", "016593", "016594", "016595", "016596", "016597", "016598", "016599", "016600", "016601", "016602", "016603", "016604", "016605", "016606", "016607", "016608", "016609", "016610", "016611", "016612", "016613", "016614", "016615", "016616", "016617", "016618", "016619", "016620", "016621", "016622", "016623", "016624", "016625", "016626", "016627", "016628", "016629", "016630", "016631", "016632", "016633", "016634", "016635", "016636", "016637", "016638", "016639", "016640", "016641", "016642", "016643", "016644", "016645", "016646", "016647", "016648", "016649", "016650", "016651", "016652", "016653", "016654", "016655", "016656", "016657", "016658", "016659", "016660", "016661", "016662", "016663", "016664", "016665", "016666", "016667", "016668", "016669", "016670", "016671", "016672", "016673", "016674", "016675", "016676", "016677", "016678", "016679", "016680", "016681", "016682", "016683", "016684", "016685", "016686", "016687", "016688", "016689", "016690", "016691", "016692", "016693", "016694", "016695", "016696", "016697"]}, "infrastructure_split": {"train": ["000000", "000001", "000002", "000003", "000004", "000005", "000006", "000007", "000008", "000009", "000010", "000011", "000012", "000013", "000014", "000015", "000016", "000017", "000018", "000019", "000020", "000021", "000022", "000023", "000024", "000025", "000026", "000027", "000028", "000029", "000030", "000031", "000032", "000033", "000034", "000035", "000036", "000037", "000038", "000039", "000040", "000041", "000042", "000043", "000044", "000045", "000046", "000047", "000048", "000049", "000050", "000051", "000052", "000053", "000054", "000055", "000056", "000057", "000058", "000059", "000060", "000061", "000062", "000063", "000064", "000065", "000066", "000067", "000068", "000069", "000070", "000071", "000072", "000073", "000074", "000075", "000076", "000077", "000078", "000079", "000080", "000081", "000082", "000083", "000084", "000085", "000086", "000087", "000088", "000089", "000090", "000091", "000092", "000093", "000094", "000095", "000096", "000097", "000098", "000099", "000100", "000101", "000102", "000103", "000104", "000105", "000106", "000107", "000108", "000109", "000110", "000111", "000112", "000113", "000114", "000115", "000116", "000117", "000118", "000119", "000120", "000121", "000122", "000123", "000124", "000125", "000126", "000127", "000128", "000129", "000130", "000131", "000132", "000133", "000134", "000135", "000136", "000137", "000138", "000139", "000140", "000141", "000142", "000143", "000144", "000145", "000146", "000147", "000148", "000149", "000150", "000151", "000152", "000153", "000154", "000155", "000156", "000157", "000158", "000159", "000160", "000161", "000162", "000163", "000164", "000165", "000166", "000167", "000168", "000169", "000170", "000171", "000172", "000173", "000174", "000175", "000176", "000177", "000178", "000179", "000180", "000181", "000182", "000183", "000184", "000185", "000186", "000187", "000188", "000189", "000190", "000191", "000192", "000193", "000194", "000195", "000196", "000197", "000198", "000199", "000200", "000201", "000202", "000203", "000204", "000205", "000206", "000207", "000208", "000209", "000210", "000211", "000212", "000213", "000214", "000215", "000216", "000217", "000218", "000219", "000220", "000221", "000222", "000223", "000224", "000225", "000226", "000227", "000228", "000229", "000230", "000231", "000232", "000233", "000234", "000235", "000236", "000237", "000238", "000239", "000240", "000241", "000242", "000243", "000244", "000245", "000246", "000247", "000248", "000249", "000250", "000251", "000252", "000253", "000254", "000255", "000256", "000257", "000258", "000259", "000260", "000261", "000262", "000263", "000264", "000265", "000266", "000267", "000268", "000269", "000270", "000271", "000272", "000273", "000274", "000275", "000276", "000277", "000278", "000279", "000280", "000281", "000282", "000283", "000284", "000285", "000286", "000287", "000288", "000289", "000290", "000291", "000292", "000293", "000294", "000295", "000296", "000297", "000298", "000299", "000300", "000301", "000302", "000303", "000304", "000305", "000306", "000307", "000308", "000309", "000310", "000311", "000312", "000313", "000314", "000315", "000316", "000317", "000318", "000319", "000320", "000321", "000322", "000323", "000324", "000325", "000326", "000327", "000328", "000329", "000330", "000331", "000332", "000333", "000334", "000335", "000336", "000337", "000338", "000339", "000340", "000341", "000342", "000343", "000344", "000345", "000346", "000347", "000348", "000349", "000350", "000351", "000352", "000353", "000354", "000355", "000356", "000357", "000358", "000359", "000360", "000361", "000362", "000363", "000364", "000365", "000366", "000367", "000368", "000369", "000370", "000371", "000372", "000373", "000374", "000375", "000376", "000377", "000378", "000379", "000380", "000381", "000382", "000383", "000384", "000385", "000386", "000387", "000388", "000389", "000390", "000391", "000392", "000393", "000394", "000395", "000396", "000397", "000398", "000399", "000400", "000401", "000402", "000403", "000404", "000405", "000406", "000407", "000408", "000409", "000410", "000411", "000412", "000413", "000414", "000415", "000416", "000417", "000418", "000419", "000420", "000421", "000422", "000423", "000424", "000425", "000426", "000427", "000428", "000429", "000430", "000431", "000432", "000433", "000434", "000435", "000436", "000437", "000438", "000439", "000440", "000441", "000442", "000443", "000444", "000445", "000446", "000447", "000448", "000449", "000450", "000451", "000452", "000453", "000454", "000455", "000456", "000457", "000458", "000459", "000460", "000461", "000462", "000463", "000464", "000465", "000466", "000467", "000468", "000469", "000470", "000471", "000472", "000473", "000474", "000475", "000476", "000477", "000478", "000479", "000480", "000481", "000482", "000483", "000484", "000485", "000486", "000487", "000488", "000489", "000490", "000491", "000492", "000493", "000494", "000495", "000496", "000497", "000498", "000499", "000500", "000501", "000502", "000503", "000504", "000505", "000506", "000507", "000508", "000509", "000510", "000511", "000512", "000513", "000514", "000515", "000516", "000517", "000518", "000519", "000520", "000521", "000522", "000523", "000524", "000525", "000526", "000527", "000528", "000529", "000530", "000531", "000532", "000533", "000534", "000535", "000536", "000537", "000538", "000539", "000540", "000541", "000542", "000543", "000544", "000545", "000546", "000547", "000548", "000549", "000550", "000551", "000552", "000553", "000554", "000555", "000556", "000557", "000558", "000559", "000560", "000561", "000562", "000563", "000564", "000565", "000566", "000567", "000568", "000569", "000570", "000571", "000572", "000573", "000574", "000575", "000576", "000577", "000578", "000579", "000580", "000581", "000582", "000583", "000584", "000585", "000586", "000587", "000588", "000589", "000590", "000591", "000592", "000593", "000594", "000595", "000596", "000597", "000598", "000599", "000600", "000601", "000602", "000603", "000604", "000605", "000606", "000607", "000608", "000609", "000610", "000611", "000612", "000613", "000614", "000615", "000616", "000617", "000618", "000619", "000620", "000621", "000622", "000623", "000624", "000625", "000626", "000627", "000628", "000629", "000630", "000631", "000632", "000633", "000634", "000635", "000636", "000637", "000638", "000639", "000640", "000641", "000642", "000643", "000644", "000645", "000646", "000647", "000648", "000649", "000650", "000651", "000652", "000653", "000654", "000655", "000656", "000657", "000658", "000659", "000660", "000661", "000662", "000663", "000664", "000665", "000666", "000667", "000668", "000669", "000670", "000671", "000672", "000673", "000674", "000675", "000676", "000677", "000678", "000679", "000680", "000681", "000682", "000683", "000684", "000685", "000686", "000687", "000688", "000689", "000690", "000691", "000692", "000693", "000694", "000695", "000696", "000697", "000698", "000699", "000700", "000701", "000702", "000703", "000704", "000705", "000706", "000707", "000708", "000709", "000710", "000711", "000712", "000713", "000714", "000715", "000716", "000717", "000718", "000719", "000720", "000721", "000722", "000723", "000724", "000725", "000726", "000727", "000728", "000729", "000730", "000731", "000732", "000733", "000734", "000735", "000736", "000737", "000738", "000739", "000740", "000741", "000742", "000743", "000744", "000745", "000746", "000747", "000748", "000749", "000750", "000751", "000752", "000753", "000754", "000755", "000756", "000757", "000758", "000759", "000760", "000761", "000762", "000763", "000764", "000765", "000766", "000767", "000768", "000769", "000770", "000771", "000772", "000773", "000774", "000775", "000776", "000777", "000778", "000779", "000780", "000781", "000782", "000783", "000784", "000785", "000786", "000787", "000788", "000789", "000790", "000791", "000792", "000793", "000794", "000795", "000796", "000797", "000798", "000799", "000800", "000801", "000802", "000803", "000804", "000805", "000806", "000807", "000808", "000809", "000810", "000811", "000812", "000813", "000814", "000815", "000816", "000817", "000818", "000819", "000820", "000821", "000822", "000823", "000824", "000825", "000826", "000827", "000828", "000829", "000830", "000831", "000832", "000833", "000834", "000835", "000836", "000837", "000838", "000839", "000840", "000841", "000842", "000843", "000844", "000845", "000846", "000847", "000848", "000849", "000850", "000851", "000852", "000853", "000854", "000855", "000856", "000857", "000858", "000859", "000860", "000861", "000862", "000863", "000864", "000865", "000866", "000867", "000868", "000869", "000870", "000871", "000872", "000873", "000874", "000875", "000876", "000877", "000878", "000879", "000880", "000881", "000882", "000883", "000884", "000885", "000886", "000887", "000888", "000889", "000890", "000891", "000892", "000893", "000894", "000895", "000896", "000897", "000898", "000899", "000900", "000901", "001124", "001125", "001126", "001127", "001128", "001129", "001130", "001131", "001132", "001133", "001134", "001135", "001136", "001137", "001138", "001139", "001140", "001141", "001142", "001143", "001144", "001145", "001146", "001147", "001149", "001150", "001151", "001152", "001153", "001154", "001155", "001156", "001157", "001158", "001159", "001160", "001161", "001162", "001163", "001164", "001165", "001166", "001167", "001168", "001169", "001170", "001171", "001172", "001173", "001174", "001175", "001176", "001177", "001178", "001179", "001180", "001181", "001182", "001183", "001184", "001185", "001186", "001187", "001188", "001189", "001190", "001191", "001192", "001193", "001194", "001195", "001196", "001197", "001198", "001199", "001200", "001201", "001202", "001203", "001204", "001205", "001206", "001207", "001208", "001209", "001210", "001211", "001212", "001213", "001214", "001215", "001216", "001217", "001218", "001219", "001220", "001221", "001222", "001223", "001224", "001225", "001226", "001227", "001228", "001229", "001230", "001231", "001232", "001233", "001234", "001235", "001236", "001237", "001238", "001239", "001240", "001241", "001242", "001243", "001244", "001245", "001246", "001247", "001248", "001249", "001250", "001251", "001252", "001253", "001254", "001255", "001256", "001257", "001258", "001259", "001260", "001261", "001262", "001263", "001264", "001265", "001266", "001267", "001268", "001269", "001270", "001271", "001272", "001273", "001274", "001275", "001276", "001277", "001278", "001279", "001280", "001281", "001282", "001283", "001284", "001285", "001286", "001287", "001288", "001289", "001290", "001291", "001292", "001293", "001294", "001295", "001296", "001297", "001298", "001299", "001300", "001301", "001302", "001303", "001304", "001305", "001306", "001307", "001308", "001309", "001310", "001311", "001312", "001313", "001314", "001315", "001316", "001317", "001318", "001319", "001320", "001321", "001322", "001323", "001324", "001325", "001326", "001327", "001328", "001329", "001330", "001331", "001332", "001333", "001334", "001335", "001336", "001337", "001338", "001339", "001340", "001341", "001342", "001343", "001344", "001345", "001346", "001347", "001348", "001349", "001350", "001351", "001352", "001353", "001354", "001355", "001356", "001357", "001358", "001359", "001360", "001361", "001362", "001363", "001364", "001365", "001366", "001367", "001368", "001369", "001370", "001371", "001372", "001373", "001374", "001375", "001376", "001377", "001378", "001379", "001380", "001381", "001382", "001383", "001384", "001385", "001386", "001387", "001388", "001389", "001390", "001391", "001392", "001393", "001394", "001395", "001396", "001397", "001398", "001399", "001400", "001401", "001402", "001403", "001404", "001405", "001406", "001407", "001408", "001409", "001410", "001411", "001412", "001413", "001414", "001415", "001416", "001417", "001418", "001419", "001420", "001421", "001422", "001423", "001424", "001425", "001426", "001427", "001428", "001429", "001430", "001431", "001432", "001433", "001434", "001435", "001436", "001437", "001438", "001439", "001440", "001441", "001442", "001443", "001444", "001445", "001446", "001447", "001448", "001449", "001450", "001451", "001452", "001453", "001454", "001455", "001456", "001457", "001458", "001459", "001460", "001461", "001462", "001463", "001464", "001465", "001466", "001467", "001468", "001469", "001470", "001471", "001472", "001473", "001474", "001475", "001476", "001477", "001478", "001479", "001480", "001481", "001482", "001483", "001484", "001485", "001486", "001487", "001488", "001489", "001490", "001491", "001492", "001493", "001494", "001495", "001496", "001497", "001498", "001499", "001500", "001501", "001502", "001503", "001504", "001505", "001506", "001507", "001508", "001509", "001510", "001511", "001512", "001513", "001514", "001515", "001516", "001517", "001518", "001519", "001520", "001521", "001522", "001523", "001524", "001525", "001526", "001527", "001528", "001529", "001535", "001536", "001537", "001538", "001539", "001540", "001541", "001542", "001543", "001544", "001545", "001546", "001547", "001548", "001549", "001550", "001551", "001552", "001553", "001554", "001555", "001556", "001557", "001558", "001559", "001560", "001561", "001562", "001563", "001564", "001565", "001566", "001567", "001568", "001569", "001570", "001571", "001572", "001573", "001574", "001575", "001576", "001577", "001578", "001579", "001580", "001947", "001948", "001949", "001950", "001951", "001952", "001953", "001954", "001955", "001956", "001957", "001958", "001959", "001960", "001961", "001962", "001963", "001964", "001965", "001966", "001967", "001968", "001969", "001970", "001971", "001972", "001973", "001974", "001975", "001976", "001977", "001978", "001979", "001980", "001981", "001982", "001983", "001984", "001985", "001986", "001987", "001988", "001989", "001990", "001991", "001992", "001993", "001994", "001995", "001996", "001997", "001998", "001999", "002000", "002001", "002002", "002003", "002004", "002005", "002006", "002007", "002008", "002009", "002010", "002011", "002012", "002013", "002014", "002015", "002016", "002017", "002018", "002019", "002020", "002021", "002022", "002023", "002024", "002025", "002026", "002027", "002028", "002029", "002030", "002031", "002032", "002033", "002034", "002035", "002036", "002037", "002038", "002039", "002040", "002041", "002042", "002043", "002044", "002045", "002046", "002047", "002048", "002049", "002050", "002051", "002052", "002053", "002054", "002055", "002056", "002057", "002058", "002059", "002060", "002061", "002062", "002063", "002064", "002065", "002066", "002067", "002068", "002069", "002070", "002071", "002072", "002073", "002074", "002075", "002076", "002077", "002078", "002079", "002080", "002081", "002082", "002083", "002084", "002085", "002086", "002087", "002088", "002089", "002090", "002091", "002092", "002093", "002094", "002095", "002096", "002097", "002098", "002099", "002100", "002101", "002102", "002103", "002104", "002105", "002106", "002107", "002108", "002109", "002110", "002111", "002112", "002113", "002114", "002115", "002116", "002117", "002118", "002119", "002120", "002121", "002122", "002123", "002124", "002125", "002126", "002127", "002128", "002129", "002130", "002131", "002132", "002133", "002134", "002135", "002136", "002137", "002138", "002139", "002140", "002141", "002142", "002143", "002144", "002145", "002146", "002147", "002148", "002149", "002150", "002151", "002152", "002153", "002154", "002155", "002156", "002157", "002158", "002159", "002343", "002344", "002345", "002346", "002347", "002348", "002349", "002350", "002351", "002352", "002353", "002354", "002355", "002356", "002357", "002358", "002359", "002360", "002361", "002362", "002363", "002364", "002365", "002366", "002367", "002368", "002369", "002370", "002371", "002372", "002373", "002374", "002375", "002376", "002377", "002378", "002379", "002380", "002381", "002382", "002383", "002384", "002385", "002386", "002387", "002388", "002389", "002390", "002391", "002392", "002393", "002394", "002395", "002396", "002397", "002398", "002399", "002400", "002401", "002402", "002403", "002404", "002405", "002406", "002407", "002408", "002409", "002410", "002411", "002412", "002413", "002414", "002415", "002416", "002417", "002418", "002419", "002420", "002421", "002422", "002423", "002439", "002440", "002441", "002442", "002443", "002444", "002445", "002446", "002447", "002448", "002449", "002450", "002451", "002452", "002453", "002454", "002455", "002456", "002457", "002458", "002459", "002460", "002461", "002462", "002463", "002464", "002465", "002466", "002467", "002468", "002469", "002470", "002471", "002472", "002473", "002474", "002475", "002476", "002477", "002478", "002479", "002480", "002481", "002482", "002483", "002484", "002485", "002486", "002487", "002488", "002489", "002490", "002491", "002492", "002493", "002494", "002495", "002496", "002497", "002498", "002499", "002500", "002501", "002502", "002503", "002504", "002505", "002506", "002507", "002508", "002509", "002510", "002511", "002512", "002513", "002514", "002515", "002516", "002517", "002518", "002519", "002520", "002521", "002522", "002523", "002524", "002525", "002526", "002527", "002528", "002529", "002530", "002531", "002532", "002533", "003356", "003357", "003358", "003359", "003360", "003361", "003362", "003363", "003364", "003365", "003366", "003367", "003368", "003369", "003370", "003371", "003372", "003373", "003374", "003375", "003376", "003377", "003378", "003379", "003380", "003381", "003382", "003383", "003384", "003385", "003386", "003387", "003388", "003389", "003390", "003391", "003392", "003393", "003394", "003395", "003396", "003397", "003398", "003399", "003400", "003401", "003402", "003403", "003404", "003405", "003406", "003424", "003425", "003426", "003427", "003428", "003429", "003430", "003431", "003432", "003433", "003434", "003435", "003436", "003437", "003438", "003439", "003440", "003441", "003442", "003443", "003444", "003445", "003446", "003447", "003448", "003449", "003450", "003451", "003452", "003453", "003454", "003455", "003456", "003457", "003458", "003459", "003460", "003461", "003462", "003463", "003464", "003465", "003466", "003467", "003468", "003469", "003470", "003471", "003472", "003473", "003474", "003475", "003476", "003477", "003478", "003479", "003480", "003481", "003482", "003483", "003484", "003485", "003486", "003487", "003488", "003489", "003490", "003491", "003492", "003493", "003494", "003495", "003496", "003497", "003498", "003499", "003500", "003501", "003502", "003503", "003504", "003505", "003506", "003507", "003508", "003509", "003510", "003511", "003512", "003513", "003514", "003515", "003516", "003517", "003639", "003640", "003641", "003642", "003643", "003644", "003645", "003646", "003647", "003648", "003649", "003650", "003651", "003652", "003653", "003654", "003655", "003656", "003657", "003658", "003659", "003660", "003661", "003662", "003663", "003664", "003665", "003666", "003667", "003668", "003669", "003670", "003671", "003672", "003673", "003674", "003675", "003676", "003677", "003678", "003679", "003680", "003681", "003682", "003683", "003684", "003685", "003686", "003687", "003688", "003689", "003690", "003691", "003692", "003693", "003694", "003695", "003696", "003697", "003698", "003699", "003700", "003701", "003702", "003703", "003704", "003705", "003706", "003707", "003708", "003709", "003710", "003711", "003712", "003713", "003714", "003715", "003716", "003717", "003718", "003719", "003720", "003721", "003722", "003723", "003724", "003725", "003726", "003727", "003728", "003729", "003730", "003731", "003732", "003733", "003734", "003735", "003736", "003737", "003738", "003739", "003740", "003741", "003742", "003743", "003744", "003745", "003746", "003747", "003748", "003749", "003750", "003751", "003752", "003753", "003754", "003755", "003756", "003757", "003758", "003759", "003760", "003761", "003762", "003763", "003764", "003765", "003766", "003767", "003768", "003769", "003770", "003771", "003772", "003773", "003774", "003775", "003776", "003777", "003778", "003779", "003780", "003781", "003782", "003783", "003784", "003785", "003786", "003787", "003788", "003789", "004416", "004417", "004418", "004419", "004420", "004421", "004422", "004423", "004424", "004425", "004426", "004427", "004428", "004429", "004430", "004431", "004432", "004433", "004434", "004435", "004436", "004437", "004438", "004439", "004440", "004441", "004442", "004443", "004444", "004445", "004446", "004447", "004448", "004449", "004450", "004451", "004452", "004453", "004454", "004455", "004456", "004457", "004458", "004459", "004460", "004461", "004462", "004463", "004464", "004465", "004466", "004467", "004468", "004469", "004470", "004471", "004472", "004473", "004474", "004475", "004476", "004477", "004478", "004479", "004480", "004481", "004482", "004483", "004484", "004485", "004486", "004487", "004488", "004489", "004490", "004491", "004492", "004493", "004494", "004495", "004496", "004497", "004498", "004499", "004500", "004501", "004502", "004503", "004504", "004505", "004506", "004507", "004508", "004509", "004510", "004511", "004512", "004513", "004514", "004515", "004516", "004517", "004518", "004519", "004520", "004521", "004522", "004523", "004524", "004525", "004526", "004527", "004528", "004529", "004530", "004531", "004532", "004533", "004534", "004535", "004536", "004537", "004538", "004539", "004540", "004541", "004542", "004543", "004544", "004545", "004546", "004547", "004548", "004549", "004550", "004551", "004552", "004553", "004554", "004555", "004556", "004557", "004558", "004559", "004560", "004561", "004562", "004563", "004564", "004565", "004566", "004567", "004568", "004569", "004570", "004571", "004572", "004573", "004574", "004575", "004576", "004577", "004578", "004579", "004580", "004581", "004582", "004583", "004584", "004585", "004586", "004587", "004588", "004589", "004590", "004591", "004592", "004593", "004594", "004595", "004596", "004597", "004598", "004599", "004600", "004601", "004602", "004603", "004604", "004605", "004606", "004607", "004608", "004609", "004610", "004611", "004612", "004613", "004614", "004615", "004616", "004617", "004618", "004619", "004620", "004621", "004622", "004623", "004624", "004625", "004626", "004627", "004628", "004629", "004630", "004631", "004632", "004633", "004634", "004635", "004636", "004637", "004638", "004639", "004640", "004641", "004642", "004643", "004644", "004645", "004646", "004647", "004648", "004649", "004650", "004651", "004652", "004653", "004654", "004655", "004656", "004657", "004658", "004659", "004660", "004661", "004662", "004663", "004664", "004665", "004666", "004667", "004668", "004669", "004670", "004671", "004672", "004673", "004674", "004675", "004676", "004677", "004678", "004679", "004680", "004681", "004682", "004683", "004684", "004685", "004686", "004687", "004688", "004689", "004690", "004691", "004692", "004693", "004694", "004695", "004696", "004697", "004698", "004699", "004700", "004701", "004702", "004703", "004704", "004705", "004706", "004707", "004708", "004709", "004710", "004711", "004712", "004713", "004714", "004715", "004716", "004717", "004718", "004860", "004861", "004862", "004863", "004864", "004865", "004866", "004867", "004868", "004869", "004870", "004871", "004872", "004873", "004874", "004875", "004876", "004877", "004878", "004879", "004880", "004881", "004882", "004883", "004884", "004885", "004886", "004887", "004888", "004889", "004890", "004891", "004892", "004893", "004894", "004895", "004896", "004897", "004898", "004899", "004900", "004920", "004921", "004922", "004923", "004924", "004925", "004926", "004927", "004928", "004929", "004930", "004931", "004932", "004933", "004934", "004935", "004936", "004937", "004938", "004939", "004940", "004941", "004942", "004943", "004944", "004945", "004946", "004947", "004948", "004949", "004950", "004951", "004952", "004953", "004954", "004955", "004956", "004957", "004958", "004959", "004960", "004961", "004962", "004963", "004964", "004965", "004966", "004967", "004968", "004969", "004970", "004971", "004972", "004973", "004974", "004975", "004976", "004977", "004978", "004979", "004980", "004981", "004982", "004983", "004984", "004985", "004986", "004987", "004988", "004989", "004990", "004991", "004992", "004993", "004994", "004995", "004996", "004997", "004998", "004999", "005000", "005001", "005002", "005003", "005004", "005005", "005006", "005007", "005008", "005009", "005010", "005011", "005012", "005013", "005014", "005015", "005016", "005017", "005018", "005019", "005020", "005021", "005022", "005023", "005024", "005025", "005026", "005027", "005028", "005029", "005030", "005031", "005032", "005033", "005034", "005035", "005036", "005037", "005038", "005039", "005040", "005041", "005042", "005043", "005044", "005045", "005046", "005047", "005048", "005049", "005050", "005051", "005587", "005588", "005589", "005590", "005591", "005592", "005593", "005594", "005595", "005596", "005597", "005598", "005599", "005600", "005601", "005602", "005603", "005604", "005605", "005606", "005607", "005608", "005609", "005610", "005611", "005612", "005613", "005614", "005615", "005616", "005617", "005618", "005619", "005620", "005621", "005622", "005623", "005624", "005625", "005626", "005627", "005628", "005629", "005630", "005631", "005632", "005633", "005634", "005635", "005636", "005637", "005638", "005639", "005640", "005641", "005642", "005643", "005644", "005645", "005646", "005647", "005648", "005649", "005650", "005651", "005652", "005653", "005654", "005655", "005656", "005657", "005658", "005659", "005660", "005661", "005662", "005663", "005664", "005665", "005666", "005667", "005668", "005669", "005670", "005671", "005672", "005673", "005674", "005675", "005676", "005677", "005678", "005679", "005680", "005681", "005682", "005683", "005684", "005685", "005686", "005687", "005688", "005689", "005690", "005691", "005692", "005693", "005694", "005695", "005696", "005697", "005698", "005699", "005700", "005701", "005702", "005703", "005704", "005705", "005706", "005707", "005708", "005709", "005710", "005711", "005712", "005713", "005714", "005715", "005716", "005717", "005718", "005719", "005720", "005721", "005722", "005723", "005724", "005725", "005726", "005727", "005728", "005729", "005730", "005731", "005732", "005733", "005734", "005735", "005736", "005737", "005738", "005739", "005740", "005741", "005742", "005743", "005744", "005745", "005746", "005747", "005748", "005749", "005750", "005751", "005752", "005753", "005754", "005755", "005756", "005757", "005758", "005759", "005760", "005761", "005762", "005763", "005764", "005765", "005766", "005767", "005768", "005769", "005770", "005771", "005772", "005773", "005774", "005775", "005776", "005777", "005778", "005779", "005780", "005781", "005782", "005783", "005784", "005785", "005786", "005787", "005788", "005789", "005790", "005791", "005792", "005793", "005794", "005795", "005796", "005797", "005798", "005799", "005800", "005801", "005802", "005803", "005804", "005805", "005806", "005807", "005808", "005809", "005810", "005811", "005812", "005813", "005814", "005815", "005816", "005817", "005818", "005819", "005820", "005821", "005822", "005823", "005824", "005825", "005826", "005827", "005828", "005829", "005830", "005831", "005832", "005833", "005834", "005835", "005836", "005837", "005838", "005839", "005840", "005841", "005842", "005843", "005844", "005845", "005846", "005847", "005848", "005849", "005850", "005851", "005852", "005853", "005854", "005855", "005856", "005857", "005858", "005859", "005860", "005861", "005862", "005863", "005864", "005865", "005866", "005867", "005868", "005869", "005870", "005871", "005872", "005873", "005874", "005875", "005876", "005877", "005878", "005879", "005880", "005881", "005882", "005883", "005884", "005885", "005886", "005887", "005888", "005889", "005890", "005891", "005892", "005893", "005894", "005895", "005896", "005897", "005898", "005899", "005900", "005901", "005902", "005903", "005904", "005905", "005906", "005907", "005908", "005909", "005910", "005911", "005912", "005913", "005914", "005915", "005916", "005917", "005918", "005919", "006102", "006103", "006104", "006105", "006106", "006107", "006108", "006109", "006110", "006111", "006112", "006113", "006114", "006115", "006116", "006117", "006118", "006119", "006120", "006121", "006122", "006123", "006124", "006125", "006126", "006127", "006128", "006129", "006130", "006131", "006132", "006133", "006134", "006135", "006136", "006137", "006138", "006139", "006140", "006141", "006142", "006143", "006144", "006145", "006146", "006147", "006148", "006149", "006150", "006151", "006152", "006153", "006154", "006155", "006156", "006157", "006158", "006159", "006160", "006161", "006162", "006163", "006164", "006165", "006166", "006167", "006168", "006169", "006170", "006171", "006172", "006173", "006174", "006175", "006176", "006177", "006178", "006179", "006180", "006181", "006182", "006183", "006184", "006185", "006186", "006187", "006188", "006189", "006190", "006191", "006192", "006193", "006194", "006195", "006196", "006197", "006198", "006199", "006200", "006201", "006202", "006203", "006204", "006205", "006206", "006207", "006208", "006209", "006210", "006211", "006212", "006213", "006214", "006215", "006216", "006217", "006218", "006219", "006220", "006221", "006222", "006223", "006224", "006225", "006226", "006227", "006228", "006229", "006230", "006231", "006232", "006233", "006234", "006235", "006236", "006237", "006238", "006239", "006240", "006241", "006242", "006243", "006244", "006245", "006246", "006247", "006248", "006249", "006250", "006251", "006252", "006253", "006254", "006255", "006256", "006257", "006258", "006259", "006260", "006261", "006262", "006263", "006264", "006265", "006266", "006267", "006268", "006269", "006270", "006271", "006272", "006273", "006274", "006275", "006276", "006277", "006278", "006279", "006280", "006281", "006282", "006283", "006284", "006285", "006286", "006287", "006288", "006289", "006290", "006291", "006292", "006293", "006294", "006295", "006296", "006297", "006298", "006299", "006300", "006301", "006302", "006303", "006304", "006305", "006306", "006307", "006308", "006309", "006310", "006311", "006312", "006313", "006314", "006315", "006316", "006317", "006318", "006319", "006320", "006321", "006322", "006323", "006324", "006325", "006326", "006327", "006328", "006329", "006330", "006331", "006332", "006333", "006334", "006335", "006336", "006337", "006338", "006339", "006340", "006341", "006342", "006343", "006344", "006345", "006346", "006347", "006348", "006349", "006350", "006351", "006352", "006353", "006354", "006355", "006356", "006357", "006358", "006359", "006360", "006361", "006362", "006363", "006364", "006365", "006366", "006367", "006368", "006369", "006370", "006371", "006372", "006373", "006374", "006375", "006376", "006377", "006378", "006379", "006380", "006381", "006382", "006383", "006384", "006385", "006386", "006387", "006388", "006389", "006390", "006391", "006392", "006393", "006394", "006395", "006396", "006397", "006398", "006399", "006400", "006401", "006402", "006403", "006404", "006405", "006406", "006407", "006408", "006409", "006410", "006411", "006412", "006413", "006414", "006415", "006416", "006417", "006418", "006419", "006420", "006421", "006422", "006423", "006424", "006425", "006426", "006427", "006428", "006429", "006430", "006431", "006432", "006433", "006434", "006435", "006436", "006437", "006438", "006439", "006440", "006441", "006442", "006443", "006444", "006445", "006446", "006447", "006448", "006449", "006450", "006451", "006452", "006453", "006454", "006455", "006456", "006457", "006458", "006459", "006460", "006461", "006462", "006463", "006464", "006465", "006466", "006467", "006468", "006469", "006470", "006471", "006472", "006473", "006474", "006475", "006476", "006477", "006478", "006479", "006480", "006481", "006482", "006483", "006484", "006485", "006486", "006487", "006488", "006489", "006490", "006491", "006492", "006493", "006494", "006495", "006496", "006497", "006498", "006499", "006500", "006501", "006502", "006503", "006504", "006505", "006506", "006507", "006508", "006509", "006510", "006511", "006512", "006513", "006514", "006515", "006516", "006517", "006518", "006519", "006520", "006521", "006522", "006523", "006524", "006525", "006526", "006527", "006528", "006529", "006530", "006531", "006532", "006533", "006534", "006535", "006536", "006537", "006538", "006539", "006540", "006541", "006542", "006543", "006544", "006545", "006546", "006547", "006548", "006549", "006550", "006551", "006552", "006553", "006554", "006555", "006556", "006557", "006558", "006559", "006560", "006561", "006562", "006563", "006564", "006565", "006566", "006567", "006568", "006569", "006570", "006571", "006572", "006573", "006574", "006575", "006576", "006577", "006578", "006579", "006580", "006581", "006582", "006583", "006584", "006585", "006586", "006587", "006588", "006589", "006590", "006591", "006592", "006593", "006594", "006595", "006596", "006597", "006598", "006599", "006600", "006601", "006602", "006603", "006604", "006605", "006606", "006607", "006608", "006609", "006610", "006611", "006612", "006613", "006614", "006615", "006616", "006617", "006618", "006619", "006620", "006621", "006622", "006623", "006624", "006625", "006626", "006627", "006628", "006629", "006630", "006631", "006632", "006633", "006634", "006635", "006636", "006637", "006638", "006639", "006640", "006641", "006642", "006643", "006644", "006645", "006646", "006647", "006648", "006649", "006650", "006651", "006652", "006653", "006654", "006655", "006656", "006657", "006658", "006659", "006660", "006661", "006662", "006663", "006664", "006665", "006666", "006667", "006668", "006669", "006670", "006671", "006672", "006673", "006674", "006675", "006676", "006677", "006678", "006679", "006680", "006681", "006682", "006683", "006684", "006685", "006686", "006687", "006688", "006689", "006690", "006691", "006692", "006693", "006694", "006695", "006696", "006697", "006698", "006699", "006700", "006701", "006702", "006703", "006704", "006705", "006706", "006707", "006708", "006709", "006710", "006711", "006712", "006713", "006714", "006715", "006716", "006717", "006718", "006719", "006720", "006721", "006722", "006723", "006724", "006725", "006726", "006727", "006728", "006729", "006730", "006731", "006732", "006733", "006734", "006735", "006736", "006737", "006738", "006739", "006740", "006741", "006742", "006743", "006744", "006745", "006746", "006747", "006748", "006749", "006750", "006751", "006752", "006753", "006754", "006755", "006756", "006757", "006758", "006759", "006760", "006761", "006762", "006763", "006764", "006765", "006766", "006767", "006768", "006769", "006770", "006771", "006772", "006773", "006774", "006775", "006776", "006777", "006778", "006779", "006780", "006781", "006782", "006783", "006784", "006785", "006786", "006787", "006788", "006789", "006790", "006791", "006792", "006793", "006794", "006795", "006796", "006797", "006798", "006799", "006800", "006801", "006802", "006803", "006804", "006805", "006806", "006807", "006808", "006809", "006810", "006811", "006812", "006813", "006814", "006815", "006816", "006817", "006818", "006819", "006820", "006821", "006822", "006823", "006824", "006825", "006826", "006827", "006828", "006829", "006830", "006831", "006832", "006833", "006834", "006835", "006836", "006837", "006838", "006839", "006840", "006841", "006842", "006843", "006844", "006845", "006846", "006847", "006848", "006849", "006850", "006851", "006852", "006853", "006854", "006855", "006856", "006857", "006858", "006859", "006860", "006861", "006862", "006863", "006864", "006865", "006866", "006867", "006868", "006869", "006870", "006871", "006872", "006873", "006874", "006875", "006876", "006877", "006878", "006879", "006880", "006881", "006882", "006883", "006884", "006885", "006886", "006887", "006888", "006889", "006890", "006891", "006892", "006893", "006894", "006895", "006896", "006897", "006898", "006899", "006900", "006901", "006902", "006903", "006904", "006905", "006906", "006907", "006908", "006909", "006910", "006911", "006912", "006913", "006914", "006915", "006916", "006917", "006918", "006919", "006920", "006921", "006922", "006923", "006924", "006925", "006926", "006927", "006928", "006929", "006930", "006931", "006932", "006933", "006934", "006935", "006936", "006937", "006938", "006939", "006940", "006941", "006942", "006943", "006944", "006945", "006946", "006947", "006948", "006949", "006950", "006951", "006952", "006953", "006954", "006955", "006956", "006957", "006958", "006959", "006960", "006961", "006962", "006963", "006964", "006965", "006966", "006967", "006968", "006969", "006970", "006971", "006972", "006973", "006974", "006975", "006976", "006977", "006978", "006979", "006980", "006981", "006982", "006983", "006984", "006985", "006986", "006987", "006988", "006989", "006990", "006991", "006992", "006993", "006994", "006995", "006996", "006997", "006998", "006999", "007000", "007001", "007002", "007003", "007004", "007005", "007006", "007007", "007448", "007449", "007450", "007451", "007452", "007453", "007454", "007455", "007456", "007457", "007458", "007459", "007460", "007461", "007462", "007463", "007464", "007465", "007466", "007467", "007468", "007469", "007470", "007471", "007472", "007473", "007474", "007475", "007476", "007477", "007478", "007479", "007480", "007481", "007482", "007483", "007484", "007485", "007486", "007487", "007488", "007489", "007490", "007491", "007492", "007493", "007494", "007495", "007496", "007497", "007498", "007499", "007500", "007501", "007502", "007503", "007504", "007505", "007506", "007507", "007508", "007509", "007510", "007511", "007512", "007513", "007514", "007515", "007516", "007517", "007518", "007519", "007520", "007521", "007522", "007523", "007524", "007525", "007526", "007527", "007528", "007529", "007530", "007531", "007532", "007533", "007534", "007535", "007536", "007537", "007538", "007539", "007540", "007541", "007542", "007543", "007544", "007545", "007546", "007547", "007548", "007549", "007550", "007551", "007552", "007553", "007554", "007555", "007556", "007557", "007558", "007559", "007560", "007561", "007562", "007563", "007564", "007565", "007566", "007567", "007574", "007575", "007576", "007577", "007578", "007579", "007580", "007581", "007582", "007583", "007584", "007585", "007586", "007587", "007588", "007589", "007590", "007591", "007592", "007593", "007594", "007595", "007596", "007597", "007598", "007599", "007600", "007601", "007602", "007603", "007604", "007605", "007606", "007607", "007608", "007609", "007610", "007611", "007612", "007613", "007614", "007615", "007616", "007617", "007618", "007619", "007620", "007621", "007622", "007623", "007624", "007625", "007626", "007627", "007628", "007629", "007630", "007631", "007632", "007633", "007634", "007635", "007636", "007637", "007638", "007639", "007640", "007641", "007642", "007643", "007644", "007645", "007646", "007647", "007648", "007649", "007650", "007651", "007652", "007653", "007654", "007655", "007656", "007657", "007658", "007659", "007660", "007661", "007662", "007663", "007664", "007665", "007666", "007667", "007668", "007669", "007670", "007671", "007672", "007673", "007674", "007675", "007676", "007677", "007678", "007679", "007680", "007681", "007682", "007683", "007684", "007685", "007686", "007687", "007688", "007689", "007690", "007691", "007692", "007693", "007694", "007695", "007696", "007697", "007698", "007699", "007700", "007701", "007702", "007703", "007704", "007705", "007706", "007707", "007708", "007709", "007710", "007711", "007712", "007713", "007714", "007715", "007716", "007717", "007718", "007719", "007720", "007721", "007722", "007723", "007724", "007725", "007726", "007727", "007728", "007729", "007730", "007731", "007732", "007733", "007734", "007735", "007736", "007737", "007738", "007739", "007740", "007741", "007742", "007743", "007744", "007745", "007746", "007747", "007748", "007749", "007750", "007751", "007752", "007753", "007754", "007755", "007756", "007757", "007758", "007759", "007760", "007761", "007762", "007763", "007764", "007765", "007766", "007767", "007768", "007769", "007770", "007771", "007772", "007773", "007774", "007775", "007776", "007777", "007778", "007779", "007780", "007781", "007782", "007783", "007784", "007785", "007786", "007787", "007788", "007789", "007790", "007791", "007792", "007793", "007794", "007795", "007796", "007797", "007798", "007799", "007800", "007801", "007802", "007803", "007804", "007805", "007806", "007807", "007808", "007809", "007810", "007811", "007812", "007813", "007814", "007815", "007816", "007817", "008688", "008689", "008690", "008691", "008692", "008693", "008694", "008695", "008696", "008697", "008698", "008699", "008700", "008701", "008702", "008703", "008704", "008705", "008706", "008707", "008708", "008709", "008710", "008711", "008712", "008713", "008714", "008715", "008716", "008717", "008718", "008719", "008720", "008721", "008722", "008723", "008724", "008725", "008726", "008727", "008728", "008729", "008730", "008731", "008732", "008733", "008734", "008735", "008736", "008737", "008738", "008739", "008740", "008741", "008742", "008743", "008744", "008745", "008746", "008747", "008748", "008749", "008750", "008751", "008752", "008753", "008754", "008755", "008756", "008757", "008758", "008759", "008760", "008761", "008762", "008763", "008764", "008765", "008766", "008767", "008768", "008769", "008770", "008771", "008772", "008773", "008774", "008775", "008776", "008777", "008778", "008779", "008780", "008781", "008782", "008783", "008784", "008785", "008786", "008787", "008788", "008789", "008790", "008791", "008792", "008793", "008794", "008795", "008796", "008797", "008798", "008799", "008800", "008801", "008802", "008803", "008804", "008805", "008806", "008807", "008808", "008809", "008810", "008811", "008812", "008813", "008814", "008815", "008816", "008817", "008818", "008819", "008820", "008821", "008822", "008823", "008824", "008825", "008826", "008827", "008828", "008829", "008830", "008831", "008832", "008833", "008834", "008835", "008836", "008837", "008838", "008839", "008840", "008841", "008842", "008843", "008844", "008845", "008846", "008847", "008848", "008849", "008850", "008851", "008852", "008853", "008854", "008855", "008856", "008857", "008858", "008859", "008860", "008861", "008862", "008863", "008864", "008865", "008866", "008867", "008868", "008869", "008870", "008871", "008872", "008873", "008874", "008875", "008876", "008877", "008878", "008879", "008880", "008881", "008882", "008883", "008884", "008885", "008886", "008887", "008888", "008889", "008890", "008891", "008892", "008893", "008894", "008895", "008896", "008897", "008898", "008899", "008900", "008901", "008902", "008903", "008904", "008905", "008906", "008907", "008908", "008909", "008910", "008911", "008912", "008913", "008914", "008915", "008916", "008917", "008918", "008919", "008920", "008921", "008922", "008923", "008924", "008925", "008926", "008927", "008928", "008929", "008930", "008931", "008932", "008933", "008934", "008935", "008936", "008937", "008938", "008939", "008940", "008941", "008942", "008943", "008944", "008945", "008946", "008947", "008948", "008949", "008950", "008951", "008952", "008953", "008954", "008955", "008956", "008957", "008958", "008959", "008960", "008961", "008962", "008963", "008964", "008965", "008966", "008967", "008968", "008969", "008970", "008971", "008972", "008973", "008974", "008975", "008976", "008977", "008978", "008979", "008980", "008981", "008982", "008983", "008984", "008985", "008986", "008987", "008988", "008989", "008990", "008991", "008992", "008993", "008994", "008995", "008996", "008997", "008998", "008999", "009000", "009001", "009002", "009003", "009004", "009005", "009006", "009007", "009008", "009009", "009010", "009011", "009012", "009013", "009014", "009015", "009016", "009017", "009018", "009019", "009020", "009021", "009022", "009023", "009024", "009025", "009026", "009027", "009028", "009029", "009030", "009031", "009032", "009033", "009034", "009035", "009036", "009037", "009038", "009039", "009040", "009041", "009042", "009043", "009044", "009045", "009046", "009047", "009048", "009049", "009050", "009051", "009052", "009053", "009054", "009055", "009056", "009057", "009058", "009059", "009060", "009061", "009062", "009063", "009064", "009065", "009066", "009067", "009068", "009069", "009070", "009071", "009072", "009073", "009074", "009075", "009076", "009077", "009078", "009079", "009080", "009081", "009082", "009083", "009084", "009085", "009086", "009087", "009088", "009089", "009090", "009091", "009092", "009093", "009094", "009095", "009096", "009097", "009098", "009099", "009100", "009101", "009102", "009103", "009104", "009105", "009106", "009107", "009108", "009109", "009110", "009111", "009112", "009113", "009114", "009115", "009116", "009117", "009118", "009119", "009120", "009121", "009122", "009123", "009124", "009125", "009126", "009127", "009128", "009129", "009130", "009131", "009132", "009133", "009134", "009135", "009136", "009137", "009138", "009139", "009140", "009141", "009142", "009143", "009144", "009145", "009146", "009147", "009148", "009149", "009150", "009151", "009152", "009153", "009154", "009155", "009156", "009157", "009158", "009159", "009160", "009161", "009162", "009163", "009164", "009165", "009166", "009167", "009168", "009169", "009170", "009171", "009172", "009173", "009174", "009175", "009176", "009177", "009178", "009179", "009180", "009181", "009182", "009183", "009184", "009185", "009186", "009187", "009188", "009189", "009190", "009191", "009192", "009193", "009194", "009195", "009196", "009197", "009198", "009199", "009200", "009201", "009202", "009203", "009204", "009205", "009206", "009207", "009208", "009209", "009210", "009211", "009212", "009213", "009214", "009215", "009216", "009217", "009218", "009219", "009220", "009221", "009222", "009223", "009224", "009225", "009226", "009227", "009228", "009229", "009230", "009231", "009232", "009233", "009234", "009235", "009236", "009237", "009238", "009239", "009240", "009241", "009242", "009243", "009244", "009245", "009246", "009247", "009248", "009249", "009250", "009251", "009252", "009253", "009254", "009255", "009256", "009257", "009258", "009259", "009260", "009261", "009262", "009263", "009264", "009265", "009266", "009267", "009268", "009269", "009270", "009271", "009272", "009273", "009274", "009275", "009276", "009277", "009278", "009279", "009280", "009281", "009282", "009283", "009284", "009285", "009286", "009287", "009288", "009289", "009290", "009291", "009292", "009293", "009294", "009295", "009296", "009297", "009298", "009299", "009300", "009301", "009302", "009303", "009304", "009305", "009306", "009307", "009308", "009309", "009310", "009311", "009312", "009313", "009314", "009315", "009316", "009317", "009318", "009319", "009320", "009321", "009322", "009323", "009324", "009325", "009326", "009327", "009328", "009329", "009330", "009331", "009332", "009333", "009334", "009335", "009336", "009337", "009338", "009339", "009340", "009341", "009342", "009343", "009344", "009345", "009346", "009347", "009348", "009349", "009350", "009351", "009352", "009353", "009354", "009355", "009356", "009357", "009358", "009359", "009360", "009361", "009362", "009363", "009364", "009365", "009366", "009367", "009368", "009909", "009910", "009911", "009912", "009913", "009914", "009915", "009916", "009917", "009918", "009919", "009920", "009921", "009922", "009923", "009924", "009925", "009926", "009927", "009928", "009929", "009930", "009931", "009932", "009933", "009934", "009935", "009936", "009937", "009938", "009939", "009940", "009941", "009942", "009943", "009944", "009945", "009946", "009947", "009948", "009949", "009950", "009951", "009952", "009953", "009954", "009955", "009956", "009957", "009958", "009959", "009960", "009961", "009962", "009963", "009964", "009965", "009966", "009967", "009968", "009969", "009970", "009971", "009972", "009973", "009974", "009975", "009976", "009977", "009978", "009979", "009980", "009981", "009982", "009983", "009984", "009985", "009986", "009987", "009988", "009989", "009990", "009991", "009992", "009993", "009994", "009995", "009996", "009997", "009998", "009999", "010000", "010001", "010002", "010003", "010004", "010005", "010006", "010007", "010008", "010009", "010010", "010011", "010012", "010013", "010014", "010015", "010016", "010017", "010018", "010019", "010020", "010021", "010022", "010023", "010024", "010025", "010026", "010027", "010028", "010029", "010030", "010031", "010032", "010033", "010034", "010035", "010036", "010037", "010038", "010039", "010040", "010041", "010042", "010043", "010044", "010045", "010046", "010047", "010048", "010049", "010050", "010051", "010052", "010053", "010054", "010055", "010056", "010057", "010058", "010059", "010060", "010061", "010062", "010063", "010064", "010065", "010066", "010067", "010068", "010069", "010070", "010071", "010072", "010073", "010074", "010075", "010076", "010077", "010078", "010079", "010080", "010081", "010082", "010083", "010084", "010085", "010086", "010087", "010088", "010089", "010090", "010091", "010092", "010093", "010094", "010095", "010096", "010097", "010098", "010099", "010100", "010101", "010102", "010103", "010104", "010105", "010106", "010107", "010108", "010109", "010110", "010111", "010112", "010113", "010114", "010115", "010116", "010117", "010118", "010119", "010120", "010121", "010122", "010123", "010124", "010125", "010126", "010127", "010128", "010129", "010130", "010131", "010132", "010133", "010134", "010135", "010136", "010137", "010138", "010139", "010140", "010141", "010142", "010143", "010144", "010145", "010146", "010147", "010148", "010149", "010150", "010151", "010152", "010153", "010154", "010155", "010156", "010157", "010158", "010159", "010160", "010161", "010162", "010163", "010164", "010165", "010166", "010167", "010168", "010169", "010170", "010171", "010172", "010173", "010174", "010175", "010176", "010177", "010178", "010179", "010180", "010181", "010182", "010183", "010184", "010185", "010186", "010187", "010188", "010189", "010190", "010191", "010192", "010193", "010194", "010195", "010196", "010197", "010198", "010199", "010200", "010201", "010202", "010203", "010204", "010205", "010206", "010207", "010208", "010209", "010210", "010211", "010212", "010213", "010214", "010215", "010216", "010217", "010218", "010219", "010220", "010221", "010222", "010223", "010224", "010225", "010226", "010227", "010228", "010229", "010230", "010231", "010232", "010233", "010234", "010235", "010236", "010237", "010238", "010239", "010240", "010241", "010242", "010243", "010244", "010245", "010246", "010247", "010248", "010249", "010250", "010251", "010252", "010253", "010254", "010255", "010256", "010257", "010258", "010259", "010260", "010261", "010262", "010263", "010264", "010265", "010266", "010267", "010268", "010269", "010270", "010271", "010272", "010273", "010274", "010275", "010276", "010277", "010278", "010279", "010280", "010281", "010282", "010283", "010284", "010285", "010286", "010287", "010288", "010289", "010290", "010291", "010292", "010293", "010294", "010295", "010296", "010297", "010298", "010299", "010300", "010301", "010302", "010303", "010304", "010305", "010306", "010307", "010308", "010309", "010310", "010311", "010312", "010313", "010314", "010315", "010316", "010317", "010318", "010319", "010320", "010321", "010322", "010323", "010324", "010325", "010326", "010327", "010328", "010329", "010330", "010331", "010332", "010333", "010334", "010335", "010336", "010337", "010338", "010339", "010340", "010341", "010342", "010343", "010344", "010345", "010346", "010347", "010348", "010349", "010350", "010351", "010352", "010353", "010354", "010355", "010356", "010357", "010358", "010359", "010360", "010361", "010362", "010363", "010364", "010365", "010366", "010367", "010368", "010369", "010370", "010371", "010372", "010373", "010374", "010375", "010376", "010377", "010378", "010379", "010380", "010381", "010382", "010383", "010384", "010385", "010386", "010387", "010388", "010389", "010390", "010391", "010392", "010393", "010394", "010395", "010396", "010397", "010398", "010399", "010400", "010401", "010402", "010403", "010404", "010405", "010406", "010407", "010408", "010409", "010410", "010411", "010412", "010413", "010414", "010415", "010416", "010417", "010418", "010419", "010420", "010421", "010422", "010423", "010424", "010425", "010426", "010427", "010428", "010429", "010430", "010431", "010432", "010433", "010434", "010435", "010436", "010437", "010438", "010439", "010440", "010441", "010442", "010443", "010444", "010445", "010446", "010447", "010448", "010449", "010450", "010451", "010452", "010453", "010454", "010455", "010456", "010457", "010458", "010459", "010460", "010461", "010462", "010463", "010464", "010465", "010466", "010467", "010468", "010469", "010470", "010471", "010472", "010473", "010474", "010475", "010476", "010477", "010478", "010479", "010480", "010481", "010482", "010483", "010484", "010485", "010486", "010487", "010488", "010489", "010490", "010491", "010492", "010493", "010494", "010495", "010496", "010497", "010498", "010499", "010500", "010501", "010502", "010503", "010504", "010505", "010506", "010507", "010508", "010509", "010510", "010511", "010512", "010513", "010514", "010515", "010516", "010517", "010518", "010519", "010520", "010521", "010522", "010523", "010524", "010525", "010526", "010527", "010528", "010529", "010530", "010531", "010532", "010533", "010534", "010535", "010536", "010537", "010538", "010539", "010540", "010541", "010542", "010543", "010544", "010545", "010546", "010547", "010548", "010549", "010550", "010551", "010552", "010553", "010554", "010555", "010556", "010557", "010558", "010559", "010560", "010561", "010562", "010563", "010564", "010565", "010566", "010567", "010568", "010569", "010570", "010571", "010572", "010573", "010574", "010575", "010576", "010577", "010578", "010579", "010580", "010581", "010582", "010583", "010584", "010585", "010586", "010587", "010588", "010589", "010590", "010591", "010592", "010593", "010594", "010595", "010596", "010597", "010598", "010599", "010600", "010601", "010602", "010603", "010604", "010605", "010606", "010607", "010608", "010609", "010610", "010611", "010612", "010613", "010614", "010615", "010616", "010617", "010618", "010619", "010620", "010621", "010622", "010623", "010624", "010625", "010626", "010627", "010628", "010635", "010636", "010637", "010638", "010639", "010640", "010641", "010642", "010643", "010644", "010645", "010646", "010647", "010648", "010649", "010650", "010651", "010652", "010653", "010654", "010655", "010656", "010657", "010658", "010659", "010660", "010661", "010662", "010663", "010664", "010665", "010666", "010667", "010668", "010669", "010670", "010671", "010672", "010673", "010674", "010675", "010676", "010677", "010678", "010679", "010680", "010681", "010682", "010683", "010684", "010685", "010686", "010687", "010688", "010689", "010690", "010691", "010692", "010693", "010694", "010695", "010696", "010697", "010698", "011160", "011161", "011162", "011163", "011164", "011165", "011166", "011167", "011168", "011169", "011170", "011171", "011172", "011173", "011174", "011176", "011177", "011178", "011179", "011180", "011181", "011182", "011183", "011184", "011185", "011186", "011187", "011188", "011189", "011190", "011191", "011192", "011193", "011194", "011195", "011196", "011197", "011198", "011199", "011200", "011201", "011202", "011203", "011204", "011205", "011206", "011207", "011208", "011209", "011210", "011211", "011212", "011213", "011214", "011215", "011216", "011217", "011218", "011219", "011220", "011221", "011222", "011223", "011224", "011225", "011226", "011227", "011228", "011229", "011230", "011231", "011232", "011233", "011234", "011235", "011236", "011237", "011238", "011239", "011240", "011241", "011242", "011243", "011244", "011245", "011246", "011247", "011248", "011249", "011250", "011251", "011252", "011253", "011254", "011255", "011256", "011257", "011258", "011259", "011260", "011261", "011262", "011263", "011264", "011265", "011266", "011267", "011268", "011269", "011270", "011271", "011272", "011273", "011274", "011275", "011276", "011277", "011278", "011279", "011280", "011281", "011282", "011283", "011284", "011285", "011286", "011287", "011288", "011289", "011290", "011291", "011292", "011293", "011294", "011295", "011296", "011297", "011298", "011299", "011300", "011301", "011302", "011303", "011304", "011305", "011306", "011307", "011308", "011309", "011310", "011311", "011312", "011313", "011314", "011315", "011316", "011317", "011318", "011319", "011320", "011321", "011322", "011323", "011324", "011325", "011326", "011327", "011328", "011329", "011330", "011331", "011332", "011333", "011334", "011335", "011336", "011337", "011338", "011339", "011340", "011341", "011342", "011343", "011344", "011345", "011346", "011347", "011348", "011349", "011350", "011351", "011352", "011353", "011354", "011355", "011356", "011357", "011358", "011359", "011360", "011361", "011362", "011363", "011364", "011365", "011366", "011367", "011368", "011369", "011370", "011371", "011372", "011373", "011374", "011375", "011376", "011377", "011378", "011379", "011468", "011469", "011470", "011471", "011472", "011473", "011474", "011475", "011476", "011477", "011478", "011479", "011480", "011481", "011482", "011483", "011484", "011485", "011486", "011487", "011488", "011489", "011490", "011491", "011492", "011493", "011494", "011495", "011496", "011497", "011498", "011499", "011500", "011501", "011502", "011503", "011504", "011505", "011506", "011507", "011508", "011509", "011510", "011511", "011512", "011513", "011514", "011515", "011516", "011517", "011518", "011519", "011520", "011521", "011522", "011523", "011524", "011525", "011526", "011527", "011528", "011529", "011530", "011531", "011532", "011533", "011534", "011535", "011536", "011537", "011538", "011539", "011540", "011541", "011542", "011543", "011544", "011545", "011546", "011547", "011548", "011549", "011550", "011551", "011552", "011553", "011554", "011555", "011556", "011557", "011558", "011559", "011560", "011561", "011562", "011563", "011564", "011565", "011566", "011567", "011568", "011569", "011570", "011571", "011572", "011573", "011574", "011575", "011580", "011581", "011582", "011583", "011584", "011585", "011586", "011587", "011588", "011589", "011590", "011591", "011592", "011593", "011594", "011595", "011596", "011597", "011598", "011599", "011600", "011601", "011602", "011603", "011604", "011605", "011606", "011607", "011608", "011609", "011610", "011611", "011612", "011613", "011614", "011615", "011616", "011617", "011618", "011619", "011620", "011621", "011622", "011623", "011624", "011625", "011626", "011627", "011628", "011629", "011630", "011631", "011632", "011633", "011634", "011635", "011636", "011637", "011638", "011639", "011640", "011641", "011642", "011643", "011644", "011645", "011646", "011647", "011648", "011649", "011650", "011651", "011652", "011653", "011654", "011655", "011656", "011657", "011658", "011659", "011660", "011661", "011662", "011663", "011664", "011665", "011666", "012229", "012230", "012231", "012232", "012233", "012234", "012235", "012236", "012237", "012238", "012239", "012240", "012241", "012242", "012243", "012244", "012245", "012246", "012247", "012248", "012249", "012250", "012251", "012252", "012253", "012254", "012255", "012256", "012257", "012258", "012259", "012260", "012261", "012262", "012263", "012264", "012265", "012266", "012267", "012268", "012269", "012270", "012271", "012272", "012273", "012274", "012275", "012276", "012277", "012278", "012279", "012280", "012281", "012282", "012283", "012284", "012285", "012286", "012287", "012288", "012289", "012290", "012291", "012292", "012293", "012294", "012295", "012296", "012297", "012298", "012299", "012300", "012301", "012302", "012303", "012304", "012305", "012306", "012307", "012308", "012309", "012310", "012311", "012312", "012313", "012314", "012315", "012316", "012317", "012318", "012319", "012320", "012321", "012322", "012323", "012324", "012325", "012326", "012327", "012328", "012329", "012330", "012331", "012332", "012333", "012334", "012335", "012336", "012337", "012338", "012339", "012340", "012341", "012342", "012343", "012344", "012345", "012346", "012347", "012348", "012349", "012350", "012351", "012352", "012353", "012354", "012355", "012356", "012357", "012358", "012359", "012360", "012361", "012362", "012363", "012364", "012365", "012366", "012367", "012368", "012369", "012370", "012371", "012372", "012373", "012374", "012375", "012376", "012377", "012378", "012379", "012380", "012381", "012382", "012383", "012384", "012385", "012386", "012387", "012388", "012389", "012390", "012391", "012392", "012393", "012394", "012395", "012396", "012397", "012398", "012399", "012400", "012401", "012402", "012403", "012404", "012405", "012406", "012407", "012408", "012409", "012410", "012411", "012412", "012413", "012414", "012415", "012416", "012417", "012418", "012419", "012420", "012421", "012422", "012423", "012424", "012425", "012426", "012427", "012428", "012429", "012430", "012431", "012432", "012433", "012434", "012435", "012436", "012437", "012438", "012439", "012440", "012441", "012589", "012590", "012591", "012592", "012593", "012594", "012595", "012596", "012597", "012598", "012599", "012600", "012601", "012602", "012603", "012604", "012605", "012606", "012607", "012608", "012609", "012610", "012611", "012612", "012613", "012614", "012615", "012616", "012617", "012618", "012619", "012620", "012621", "012622", "012623", "012624", "012625", "012626", "012627", "012628", "012629", "012630", "012631", "012632", "012633", "012634", "012635", "012636", "012637", "012638", "012639", "012640", "012641", "012642", "012643", "012644", "012645", "012646", "012647", "012648", "012649", "012650", "012651", "012652", "012653", "012654", "012655", "012656", "012657", "012658", "012659", "012660", "012661", "012662", "012663", "012664", "012665", "012666", "012667", "012668", "012669", "012670", "012671", "012672", "012673", "012674", "012675", "012676", "012677", "012678", "012679", "012680", "012681", "012682", "012683", "012684", "012685", "012686", "012687", "012688", "012689", "012690", "012691", "012692", "012693", "012694", "012695", "012696", "012697", "012698", "012699", "012700", "012701", "012702", "012703", "012704", "012705", "012706", "012707", "012708", "012709", "012710", "012711", "012712", "012713", "012714", "012715", "012716", "012717", "012718", "012719", "012720", "012721", "012722", "012723", "012724", "012725", "012726", "012727", "012728", "012729", "012730", "012731", "012732", "012733", "012734", "012735", "012736", "012737", "012738", "012739", "012740", "012741", "012742", "012937", "012938", "012939", "012940", "012941", "012942", "012943", "012944", "012945", "012946", "012947", "012948", "012949", "012950", "012951", "012952", "012953", "012954", "012955", "012956", "012957", "012958", "012959", "012960", "012961", "012962", "012963", "012964", "012965", "012966", "012967", "012968", "012969", "012970", "012971", "012972", "012973", "012974", "012975", "012976", "012977", "012978", "012979", "012980", "012981", "012982", "012983", "012984", "012985", "012986", "012987", "012988", "012989", "012990", "012991", "012992", "012993", "012994", "012995", "012996", "012997", "012998", "012999", "013000", "013001", "013002", "013003", "013004", "013005", "013006", "013007", "013008", "013009", "013010", "013011", "013012", "013013", "013014", "013015", "013016", "013017", "013018", "013019", "013020", "013021", "013022", "013023", "013024", "013025", "013026", "013027", "013028", "013029", "013030", "013031", "013032", "013033", "013034", "013035", "013036", "013037", "013038", "013039", "013040", "013041", "013042", "013043", "013044", "013045", "013046", "013047", "013048", "013049", "013050", "013051", "013052", "013053", "013054", "013055", "013056", "013057", "013058", "013059", "013060", "013061", "013062", "013063", "013064", "013065", "013066", "013067", "013068", "013069", "013070", "013071", "013072", "013073", "013074", "013075", "013076", "013077", "013078", "013079", "013080", "013081", "013082", "013083", "013084", "013085", "013086", "013087", "013088", "013089", "013090", "013091", "013092", "013093", "013094", "013095", "013096", "013097", "013098", "013099", "013100", "013101", "013102", "013103", "013104", "013105", "013106", "013107", "013108", "013109", "013110", "013111", "013112", "013113", "013114", "013115", "013116", "013117", "013118", "013119", "013120", "013121", "013122", "013123", "013124", "013125", "013126", "013127", "013128", "013129", "013130", "013131", "013132", "013133", "013134", "013135", "013136", "013137", "013138", "013139", "013140", "013141", "013142", "013143", "013144", "013145", "013146", "013147", "013148", "013149", "013150", "013151", "013152", "013153", "013154", "013155", "013156", "013375", "013376", "013377", "013378", "013379", "013380", "013381", "013382", "013383", "013384", "013385", "013386", "013387", "013388", "013389", "013390", "013391", "013392", "013393", "013394", "013395", "013396", "013397", "013398", "013399", "013400", "013401", "013402", "013403", "013404", "013405", "013406", "013407", "013408", "013409", "013410", "013411", "013412", "013413", "013414", "013415", "013416", "013417", "013418", "013419", "013420", "013421", "013422", "013423", "013424", "013425", "013426", "013427", "013428", "013429", "013430", "013431", "013432", "013433", "013434", "013435", "013436", "013437", "013438", "013439", "013440", "013441", "013442", "013443", "013444", "013445", "013446", "013447", "013448", "013449", "013450", "013451", "013452", "013453", "013454", "013455", "013456", "013457", "013458", "013459", "013460", "013461", "013462", "013463", "013464", "013465", "013466", "013467", "013468", "013469", "013470", "013471", "013472", "013473", "013474", "013475", "013476", "013477", "013478", "013479", "013480", "013481", "013482", "013483", "013484", "013485", "013486", "013487", "013488", "013489", "013490", "013491", "013492", "013493", "013494", "013495", "013496", "013497", "013498", "013499", "013500", "013501", "013502", "013503", "013504", "013505", "013506", "013507", "013508", "013509", "013510", "013511", "013512", "013513", "013514", "013515", "013516", "013517", "013518", "013519", "013520", "013521", "013522", "013974", "013975", "013976", "013977", "013978", "013979", "013980", "013981", "013982", "013983", "013984", "013985", "013986", "013987", "013988", "013989", "013990", "013991", "013992", "013993", "013994", "013995", "013996", "013997", "013998", "013999", "014000", "014001", "014002", "014003", "014004", "014005", "014006", "014007", "014008", "014009", "014010", "014011", "014012", "014013", "014014", "014015", "014016", "014017", "014018", "014019", "014020", "014021", "014022", "014023", "014024", "014025", "014026", "014027", "014028", "014029", "014030", "014031", "014032", "014033", "014034", "014035", "014036", "014037", "014038", "014039", "014040", "014041", "014042", "014043", "014044", "014045", "014046", "014047", "014048", "014049", "014050", "014051", "014052", "014053", "014054", "014055", "014056", "014057", "014058", "014059", "014060", "014061", "014062", "014063", "014064", "014065", "014066", "014067", "014068", "014069", "014070", "014071", "014072", "014073", "014074", "014075", "014076", "014077", "014078", "014079", "014080", "014081", "014082", "014083", "014084", "014085", "014086", "014087", "014088", "014089", "014090", "014091", "014092", "014093", "014094", "014095", "014096", "014097", "014098", "014099", "014100", "014101", "014102", "014103", "014104", "014105", "014106", "014107", "014108", "014109", "014110", "014111", "014112", "014113", "014114", "014115", "014116", "014117", "014118", "014119", "014120", "014121", "014122", "014123", "014124", "014125", "014126", "014127", "014128", "014129", "014130", "014131", "014132", "014133", "014134", "014135", "014136", "014137", "014138", "014139", "014140", "014141", "014142", "014143", "014144", "014145", "014146", "014147", "014148", "014149", "014150", "014151", "014152", "014153", "014154", "014155", "014156", "014157", "014158", "014159", "014160", "014161", "014162", "014163", "014164", "014165", "014166", "014167", "014168", "014169", "014170", "014171", "014172", "014173", "014174", "014175", "014176", "014177", "014178", "014179", "014180", "014181", "014182", "014183", "014184", "014185", "014186", "014187", "014188", "014189", "014190", "014191", "014192", "014193", "014194", "014195", "014196", "014197", "014198", "014199", "014200", "014201", "014202", "014203", "014204", "014205", "014206", "014207", "014208", "014209", "014210", "014211", "014212", "014213", "014214", "014215", "014216", "014217", "014218", "014219", "014220", "014221", "014222", "014223", "014224", "014225", "014226", "014227", "014228", "014229", "014230", "014231", "014232", "014233", "014234", "014235", "014236", "014237", "014238", "014239", "014240", "014241", "014242", "014243", "014244", "014245", "014246", "014247", "014248", "014249", "014250", "014251", "014252", "014253", "014254", "014255", "014256", "014257", "014258", "014259", "014260", "014261", "014262", "014263", "014264", "014265", "014266", "014267", "014268", "014269", "014270", "014271", "014272", "014273", "014274", "014275", "014276", "014277", "014278", "014279", "014280", "014281", "014282", "014283", "014284", "014285", "014286", "014287", "014288", "014289", "014290", "014291", "014292", "014293", "014294", "014295", "014296", "014297", "014298", "014299", "014300", "014301", "014302", "014303", "014304", "014305", "014306", "014307", "014308", "014309", "014310", "014311", "014312", "014313", "014314", "014315", "014316", "014317", "014318", "014319", "014320", "014321", "014322", "014323", "014324", "014325", "014326", "014327", "014328", "014329", "014330", "014331", "014332", "014333", "014334", "014335", "014336", "014337", "014338", "014339", "014340", "014341", "014342", "014343", "014344", "014345", "014346", "014347", "014348", "014349", "014350", "014351", "014352", "014353", "014354", "014355", "014356", "014357", "014358", "014359", "014360", "014361", "014362", "014363", "014364", "014365", "014366", "014367", "014368", "014369", "014370", "014371", "014372", "014373", "014374", "014375", "014376", "014377", "014378", "014379", "014380", "014381", "014382", "014383", "014384", "014385", "014386", "014387", "014388", "014389", "014390", "014391", "014392", "014393", "014394", "014395", "014396", "014397", "014398", "014399", "014400", "014401", "014402", "014403", "014404", "014405", "014406", "014407", "014408", "014409", "014410", "014411", "014412", "014413", "014414", "014415", "014416", "014417", "014418", "014419", "014420", "014421", "014422", "014423", "014424", "014425", "014426", "014427", "014428", "014429", "014430", "014431", "014432", "014433", "014434", "014435", "014436", "014437", "014438", "014439", "014440", "014441", "014442", "014443", "014444", "014445", "014446", "014447", "014448", "014449", "014450", "014451", "014452", "014453", "014454", "014455", "014456", "014457", "014458", "014459", "014460", "014461", "014462", "014463", "014464", "014465", "014466", "014467", "014468", "014469", "014470", "014471", "014472", "014473", "014474", "014475", "014476", "014477", "014478", "014479", "014480", "014481", "014482", "014483", "014484", "014485", "014486", "014487", "014488", "014489", "014490", "014491", "014492", "014493", "014494", "014495", "014496", "014497", "014498", "014499", "014500", "014501", "014502", "014503", "014504", "014505", "014506", "014507", "014508", "014509", "014510", "014511", "014512", "014513", "014514", "014515", "014516", "014517", "014518", "014519", "014520", "014521", "014522", "014523", "014524", "014525", "014526", "014527", "014528", "014529", "014530", "014531", "014532", "014533", "014534", "014535", "014536", "014537", "014538", "014539", "014540", "014541", "014542", "014543", "014544", "014545", "014546", "014547", "014548", "014549", "014550", "014551", "014552", "014553", "014554", "014555", "014556", "014557", "014558", "014559", "014560", "014561", "014562", "014563", "014564", "014565", "014566", "014567", "014568", "014569", "014570", "014571", "014572", "014573", "014574", "014575", "014576", "014577", "014578", "014579", "014580", "014581", "014582", "014583", "014584", "014585", "014586", "014587", "014588", "014589", "014590", "014591", "014592", "014593", "014594", "014595", "014596", "014597", "014598", "014599", "014600", "014601", "014602", "014603", "014604", "014605", "014606", "014607", "014693", "014694", "014695", "014696", "014697", "014698", "014699", "014700", "014701", "014702", "014703", "014704", "014705", "014706", "014707", "014708", "014709", "014710", "014711", "014712", "014713", "014714", "014715", "014716", "014717", "014718", "014719", "014720", "014721", "014722", "014723", "014724", "014725", "014726", "014727", "014728", "014729", "014730", "014731", "014732", "014733", "014734", "014735", "014736", "014737", "014738", "014739", "014740", "014741", "014742", "014743", "014744", "014745", "014746", "014747", "014748", "014749", "014750", "014751", "014752", "014753", "014754", "014755", "014996", "014997", "014998", "014999", "015000", "015001", "015002", "015003", "015004", "015005", "015006", "015007", "015008", "015009", "015010", "015011", "015012", "015013", "015014", "015015", "015016", "015017", "015873", "015874", "015875", "015876", "015877", "015878", "015879", "015880", "015881", "015882", "015883", "015884", "015885", "015886", "015887", "015888", "015889", "015890", "015891", "015892", "015893", "015894", "015895", "015896", "015897", "015898", "015899", "015900", "015901", "015902", "015903", "015904", "015905", "015906", "015907", "015908", "015909", "015910", "015911", "015912", "015913", "015914", "015915", "015916", "015917", "015918", "015919", "015920", "015921", "015922", "015923", "015924", "015925", "015926", "015927", "015928", "015929", "015930", "015931", "015932", "015933", "015934", "015935", "015936", "015937", "015938", "015939", "015940", "015941", "015942", "015943", "015944", "015945", "015946", "015947", "015948", "015949", "015950", "015951", "015952", "015953", "015954", "015955", "015956", "015957", "015958", "015959", "015960", "015961", "015962", "015963", "015964", "015965", "015966", "015967", "015968", "015969", "015970", "015971", "015972", "015973", "015974", "015975", "015976", "015977", "015978", "015979", "015980", "015981", "015982", "015983", "015984", "015985", "015986", "015987", "015988", "015989", "015990", "015991", "015992", "015993", "015994", "015995", "015996", "015997", "015998", "015999", "016000", "016001", "016002", "016003", "016004", "016005", "016006", "016007", "016008", "016009", "016010", "016011", "016012", "016013", "016014", "016015", "016016", "016017", "016018", "016019", "016020", "016021", "016022", "016023", "016024", "016025", "016026", "016027", "016028", "016029", "016030", "016031", "016032", "016033", "016034", "016035", "016036", "016037", "016038", "016039", "016040", "016041", "016042", "016043", "016044", "016045", "016046", "016047", "016048", "016049", "016050", "016051", "016052", "016053", "016054", "016055", "016056", "016057", "016058", "016059", "016060", "016061", "016062", "016063", "016064", "016065", "016066", "016067", "016068", "016069", "016070", "016071", "016072", "016073", "016074", "016075", "016076", "016077", "016078", "016079", "016080", "016081", "016082", "016083", "016084", "016085", "016086", "016087", "016088", "016089", "016090", "016091", "016092", "016093", "016094", "016095", "016096", "016097", "016098", "016099", "016100", "016101", "016102", "016103", "016104", "016105", "016106", "016107", "016108", "016109", "016110", "016111", "016112", "016113", "016114", "016115", "016116", "016117", "016118", "016119", "016120", "016121", "016122", "016123", "016124", "016125", "016126", "016127", "016128", "016129", "016130", "016131", "016132", "016133", "016134", "016135", "016136", "016137", "016138", "016139", "016140", "016141", "016142", "016143", "016144", "016145", "016146", "016147", "016148", "016149", "016150", "016151", "016152", "016153", "016154", "016155", "016156", "016157", "016158", "016159", "016160", "016161", "016162", "016163", "016164", "016165", "016166", "016167", "016168", "016169", "016170", "016171", "016172", "016173", "016174", "016175", "016176", "016177", "016178", "016179", "016180", "016181", "016182", "016183", "016184", "016185", "016186", "016187", "016188", "016189", "016190", "016191", "016192", "016193", "016194", "016195", "016196", "016197", "016198", "016199", "016200", "016201", "016202", "016203", "016204", "016205", "016206", "016207", "016208", "016209", "016210", "016211", "016212", "016213", "016214", "016215", "016216", "016217", "016218", "016219", "016220", "016221", "016222", "016223", "016224", "016225", "016226", "016227", "016228", "016229", "016230", "016231", "016232", "016233", "016234", "016235", "016236", "016237", "016238", "016239", "016240", "016241", "016242", "016243", "016244", "016245", "016246", "016247", "016248", "016249", "016250", "016251", "016252", "016253", "016254", "016255", "016256"], "val": ["000902", "000903", "000904", "000905", "000906", "000907", "000908", "000909", "000910", "000911", "000912", "000913", "000914", "000915", "000916", "000917", "000918", "000919", "000920", "000921", "000922", "000923", "000924", "000925", "000926", "000927", "000928", "000929", "000930", "000931", "000932", "000933", "000934", "000935", "000936", "000937", "000938", "000939", "000940", "000941", "000942", "000943", "000944", "000945", "000946", "000947", "000948", "000949", "000950", "000951", "000952", "000953", "000954", "000955", "000956", "000957", "000958", "000959", "000960", "000961", "000962", "000963", "000964", "000965", "000966", "000967", "000968", "000969", "000970", "000971", "000972", "000973", "000974", "000975", "000976", "000977", "000978", "000979", "000980", "000981", "000982", "000983", "000984", "000985", "000986", "000987", "000988", "000989", "000990", "000991", "000992", "000993", "000994", "000995", "000996", "000997", "000998", "000999", "001000", "001001", "001002", "001003", "001004", "001005", "001006", "001007", "001008", "001009", "001010", "001011", "001012", "001013", "001014", "001015", "001016", "001017", "001018", "001019", "001020", "001021", "001022", "001023", "001024", "001025", "001026", "001027", "001028", "001029", "001030", "001031", "001032", "001033", "001034", "001035", "001036", "001037", "001038", "001039", "001040", "001041", "001042", "001043", "001044", "001045", "001046", "001047", "001048", "001049", "001050", "001051", "001052", "001053", "001054", "001055", "001056", "001057", "001058", "001059", "001060", "001061", "001062", "001063", "001064", "001065", "001066", "001067", "001068", "001069", "001070", "001071", "001072", "001073", "001074", "001075", "001076", "001077", "001078", "001079", "001080", "001081", "001082", "001083", "001084", "001085", "001086", "001087", "001088", "001089", "001090", "001091", "001092", "001093", "001094", "001095", "001096", "001097", "001098", "001099", "001100", "001101", "001102", "001103", "001104", "001105", "001106", "001107", "001108", "001109", "001110", "001111", "001112", "001113", "001114", "001115", "001116", "001117", "001118", "001119", "001120", "001121", "001122", "001123", "001787", "001788", "001789", "001790", "001791", "001792", "001793", "001794", "001795", "001796", "001797", "001798", "001799", "001800", "001801", "001802", "001803", "001804", "001805", "001806", "001807", "001808", "001809", "001810", "001811", "001812", "001813", "001814", "001815", "001816", "001817", "001818", "001819", "001820", "001821", "001822", "001823", "001824", "001825", "001826", "001827", "001828", "001829", "001830", "001831", "001832", "001833", "001834", "001835", "001836", "001837", "001838", "001839", "001840", "001841", "001842", "001843", "001844", "001845", "001846", "001847", "001848", "001849", "001850", "001851", "001852", "001853", "001854", "001855", "001856", "001857", "001858", "001859", "001860", "001861", "001862", "001863", "001864", "001865", "001866", "001867", "001868", "001869", "001870", "001871", "001872", "001873", "001874", "001875", "001876", "001877", "001878", "001879", "001880", "001881", "001882", "001883", "001884", "001885", "001889", "001890", "001891", "001892", "001893", "001894", "001895", "001896", "001897", "001898", "001899", "001900", "001901", "001902", "001903", "001904", "001905", "001906", "001907", "001908", "001909", "001910", "001911", "001912", "001913", "001914", "001915", "001916", "001917", "001918", "001919", "001920", "001921", "001922", "001923", "001924", "001925", "001926", "001927", "001928", "001929", "001930", "001931", "001932", "001933", "001934", "001935", "001936", "001937", "001938", "001939", "001940", "001941", "001942", "001943", "001944", "001945", "001946", "003019", "003020", "003021", "003022", "003023", "003024", "003025", "003026", "003027", "003028", "003029", "003030", "003031", "003032", "003033", "003034", "003035", "003036", "003037", "003038", "003039", "003040", "003041", "003042", "003043", "003044", "003045", "003046", "003047", "003048", "003049", "003050", "003051", "003052", "003053", "003054", "003055", "003056", "003057", "003058", "003059", "003060", "003061", "003062", "003063", "003064", "003065", "003066", "003067", "003068", "003069", "003070", "003071", "003072", "003073", "003074", "003075", "003076", "003077", "003078", "003079", "003080", "003081", "003082", "003083", "003084", "003085", "003086", "003087", "003088", "003089", "003090", "003091", "003092", "003093", "003094", "003095", "003096", "003097", "003098", "003099", "003100", "003101", "003102", "003103", "003104", "003105", "003106", "003107", "003108", "003109", "003110", "003111", "003112", "003113", "003114", "003115", "003116", "003117", "003118", "003119", "003120", "003121", "003122", "003123", "003124", "003125", "003126", "003127", "003128", "003129", "003130", "003131", "003132", "003133", "003134", "003135", "003136", "003137", "003138", "003139", "003140", "003141", "003142", "003143", "003144", "003145", "003146", "003147", "003148", "003149", "003150", "003151", "003152", "003153", "003154", "003155", "003156", "003157", "003158", "003159", "003160", "003161", "003162", "003163", "003164", "003165", "003166", "003167", "003168", "003169", "003170", "003171", "003172", "003173", "003174", "003175", "003176", "003177", "003178", "003179", "003180", "003181", "003182", "003183", "003184", "003185", "003186", "003187", "003188", "003189", "003190", "003191", "003192", "003193", "003194", "003195", "003196", "003197", "003198", "003199", "003200", "003201", "003202", "003203", "003204", "003205", "003206", "003207", "003208", "003209", "003210", "003211", "003212", "003213", "003214", "003215", "003216", "003217", "003218", "003219", "003220", "003221", "003222", "003223", "003224", "003225", "003226", "003227", "003228", "003229", "003230", "003231", "003232", "003233", "003234", "003235", "003236", "003237", "003238", "003239", "003240", "003241", "003242", "003243", "003244", "003245", "003246", "003247", "003248", "003249", "003250", "003251", "003252", "003253", "003254", "003255", "003256", "003257", "003258", "003259", "003260", "003261", "003262", "003263", "003264", "003265", "003266", "003267", "003268", "003269", "003270", "003271", "003272", "003273", "003274", "003275", "003276", "003277", "003278", "003279", "003280", "003281", "003282", "003283", "003284", "003285", "003286", "003287", "003288", "003289", "003290", "003291", "003292", "003293", "003294", "003295", "003296", "003297", "003298", "003299", "003300", "003301", "003302", "003303", "003304", "003305", "003306", "003307", "003308", "003309", "003310", "003311", "003312", "003313", "003314", "003315", "003316", "003317", "003318", "003319", "003320", "003321", "003322", "003323", "003324", "003325", "003326", "003327", "003328", "003329", "003330", "003331", "003332", "003333", "003334", "003335", "003336", "003337", "003338", "003339", "003340", "003341", "003342", "003343", "003344", "003345", "003346", "003347", "003348", "003349", "003350", "003351", "003352", "003353", "003354", "003355", "003518", "003519", "003520", "003521", "003522", "003523", "003524", "003525", "003526", "003527", "003528", "003529", "003530", "003531", "003532", "003533", "003534", "003535", "003536", "003537", "003538", "003539", "003540", "003541", "003542", "003543", "003544", "003545", "003546", "003547", "003565", "003566", "003567", "003568", "003569", "003570", "003571", "003572", "003573", "003574", "003575", "003576", "003577", "003578", "003579", "003580", "003581", "003582", "003583", "003584", "003585", "003586", "003587", "003588", "003589", "003590", "003591", "003592", "003593", "003594", "003595", "003596", "003597", "003598", "003599", "003600", "003601", "003602", "003603", "003604", "003605", "003606", "003607", "003608", "003609", "003610", "003611", "003612", "003613", "003614", "003615", "003616", "003617", "003618", "003619", "003620", "003621", "003622", "003623", "003624", "003625", "003626", "003627", "003628", "003629", "003630", "003631", "003632", "003633", "003634", "003635", "003636", "003637", "003638", "004013", "004014", "004015", "004016", "004017", "004018", "004019", "004020", "004021", "004022", "004023", "004024", "004025", "004026", "004027", "004028", "004029", "004030", "004031", "004032", "004033", "004034", "004035", "004036", "004037", "004038", "004039", "004040", "004041", "004042", "004043", "004044", "004045", "004046", "004047", "004048", "004049", "004050", "004051", "004052", "004053", "004054", "004055", "004056", "004057", "004058", "004059", "004060", "004061", "004062", "004063", "004064", "004065", "004066", "004067", "004068", "004069", "004070", "004071", "004072", "004073", "004074", "004075", "004076", "004077", "004078", "004079", "004080", "004081", "004082", "004083", "004084", "004085", "004086", "004087", "004088", "004089", "004090", "004091", "004092", "004093", "004094", "004095", "004096", "004097", "004098", "004099", "004100", "004101", "004102", "004103", "004104", "004105", "004106", "004107", "004108", "004109", "004110", "004111", "004112", "004113", "004114", "004115", "004116", "004117", "004118", "004119", "004120", "004121", "004122", "004123", "004124", "004125", "004126", "004127", "004128", "004129", "004130", "004131", "004132", "004133", "004134", "004135", "004136", "004137", "004138", "004139", "004140", "004141", "004142", "004143", "004144", "004145", "004146", "004147", "004148", "004149", "004150", "004151", "004152", "004153", "004154", "004155", "004156", "004157", "004158", "004159", "004160", "004161", "004162", "004163", "004164", "004165", "004166", "004167", "004168", "004169", "004170", "004171", "004172", "004173", "004174", "004175", "004176", "004177", "004178", "004179", "004180", "004181", "004182", "004183", "004184", "004185", "004186", "004187", "004188", "004189", "004190", "004191", "004192", "004193", "004194", "004195", "004196", "004197", "004198", "004199", "004200", "004201", "004202", "004203", "004204", "004205", "004206", "004207", "004208", "004209", "004210", "004211", "004212", "004213", "004214", "004215", "004216", "004217", "004218", "004219", "004220", "004221", "004222", "004223", "004224", "004225", "004226", "004227", "004228", "004229", "004230", "004231", "004232", "004233", "004234", "004235", "004236", "004237", "004238", "004239", "004240", "004241", "004242", "004243", "004244", "004245", "004246", "004247", "004248", "004249", "004250", "004251", "004252", "004253", "004254", "004255", "004256", "004257", "004258", "004259", "004260", "004261", "004262", "004263", "004264", "004265", "004266", "004267", "004268", "004269", "004270", "004271", "004272", "004273", "004274", "004275", "004276", "004277", "004278", "004279", "004280", "004281", "004282", "004283", "004284", "004285", "004286", "004287", "004288", "004289", "004290", "004291", "004292", "004293", "004294", "004295", "004296", "004297", "004298", "004299", "004300", "004301", "004302", "004303", "004304", "004305", "004306", "004307", "004308", "004309", "004310", "004311", "004312", "004313", "004314", "004315", "004316", "004317", "004318", "004319", "004320", "004321", "004322", "004323", "004324", "004325", "004326", "004327", "004328", "004329", "004330", "004331", "004332", "004333", "004334", "004335", "004336", "004337", "004338", "004339", "004340", "004341", "004342", "004343", "004344", "004345", "004346", "004347", "004348", "004349", "004350", "004351", "004352", "004353", "004354", "004355", "004356", "004357", "004358", "004359", "004360", "004361", "004362", "004363", "004364", "004365", "004366", "004367", "004368", "004369", "004370", "004371", "004372", "004373", "004374", "004375", "004376", "004377", "004378", "004379", "004380", "004381", "004382", "004383", "004384", "004385", "004386", "004387", "004388", "004389", "004390", "004391", "004392", "004393", "004394", "004395", "004396", "004397", "004398", "004399", "004400", "004401", "004402", "004403", "004404", "004405", "004406", "004407", "004408", "004409", "004410", "004411", "004412", "004413", "004414", "004415", "007818", "007819", "007820", "007821", "007822", "007823", "007824", "007825", "007826", "007827", "007828", "007829", "007830", "007831", "007832", "007833", "007834", "007835", "007836", "007837", "007838", "007839", "007840", "007841", "007842", "007843", "007844", "007845", "007846", "007847", "007848", "007849", "007850", "007851", "007852", "007853", "007854", "007855", "007856", "007857", "007858", "007859", "007860", "007861", "007862", "007863", "007864", "007865", "007866", "007867", "007868", "007869", "007870", "007871", "007872", "007873", "007874", "007875", "007876", "007877", "007878", "007879", "007880", "007881", "007882", "007883", "007884", "007885", "007886", "007887", "007888", "007889", "007890", "007891", "007892", "007893", "007894", "007895", "007896", "007897", "007898", "007899", "007900", "007901", "007902", "007903", "007904", "007905", "007906", "007907", "007908", "007909", "007910", "007911", "007912", "007913", "007914", "007915", "007916", "007917", "007918", "007919", "007920", "007921", "007922", "007923", "007924", "007925", "007926", "007927", "007928", "007929", "007930", "007931", "007932", "007933", "007934", "007935", "007936", "007937", "007938", "007939", "007940", "007941", "007942", "007943", "007944", "007945", "007946", "007947", "007948", "007949", "007950", "007951", "007952", "007953", "007954", "007955", "007956", "007957", "007958", "007959", "007960", "007961", "007962", "007963", "007964", "007965", "007966", "007967", "007968", "007969", "007970", "007971", "007972", "007973", "007974", "007975", "007976", "007977", "007978", "007979", "007980", "007981", "007982", "007983", "007984", "007985", "007986", "007987", "009579", "009580", "009581", "009582", "009583", "009584", "009585", "009586", "009587", "009588", "009589", "009590", "009591", "009592", "009593", "009594", "009595", "009596", "009597", "009598", "009599", "009600", "009601", "009602", "009603", "009604", "009605", "009606", "009607", "009608", "009609", "009610", "009611", "009612", "009613", "009614", "009615", "009616", "009617", "009618", "009619", "009620", "009621", "009622", "009623", "009624", "009625", "009626", "009627", "009628", "009629", "009630", "009631", "009632", "009633", "009634", "009635", "009636", "009637", "009638", "009639", "009640", "009641", "009642", "009643", "009644", "009645", "009646", "009647", "009648", "009649", "009650", "009651", "009652", "009653", "009654", "009655", "009656", "009657", "009658", "009659", "009660", "009661", "009662", "009663", "009664", "009665", "009666", "009667", "009668", "009669", "009670", "009671", "009672", "009673", "009674", "009675", "009676", "009677", "009678", "009679", "009680", "009681", "009682", "009683", "009684", "009685", "009686", "009687", "009688", "009689", "009690", "009691", "009692", "009693", "009694", "009695", "009696", "009697", "009698", "009701", "009702", "009703", "009704", "009705", "009706", "009707", "009708", "009709", "009710", "009711", "009712", "009713", "009714", "009715", "009716", "009717", "009718", "010699", "010700", "010701", "010702", "010703", "010704", "010705", "010706", "010707", "010708", "010709", "010710", "010711", "010712", "010713", "010714", "010715", "010716", "010717", "010718", "010719", "010720", "010721", "010722", "010723", "010724", "010725", "010726", "010727", "010728", "010729", "010730", "010731", "010732", "010733", "010734", "010735", "010736", "010737", "010738", "010739", "010740", "010741", "010742", "010743", "010744", "010745", "010746", "010747", "010748", "010749", "010750", "010751", "010752", "010753", "010754", "010755", "010756", "010757", "010758", "010759", "010760", "010761", "010762", "010763", "010764", "010765", "010766", "010767", "010768", "010769", "010770", "010771", "010772", "010773", "010774", "010775", "010776", "010777", "010778", "010779", "010780", "010781", "010782", "010783", "010784", "010785", "010786", "010787", "010788", "010789", "010790", "010791", "010792", "010793", "010794", "010795", "010796", "010797", "010798", "010799", "010800", "010801", "010802", "010803", "010804", "010805", "010806", "010807", "010808", "010809", "010810", "010811", "010812", "010813", "010814", "010815", "010816", "010817", "010818", "010819", "010820", "010821", "010822", "010823", "010824", "010825", "010826", "010827", "010828", "010829", "010830", "010831", "010832", "010833", "010834", "010835", "010836", "010837", "010838", "010839", "010840", "010841", "010842", "010843", "010844", "010845", "010846", "010847", "010848", "010849", "010850", "010851", "010852", "010853", "010854", "010855", "010856", "010857", "010858", "010859", "010860", "010861", "010862", "010863", "010864", "010865", "010866", "010867", "010868", "010869", "010870", "010871", "010872", "010873", "010874", "010875", "010876", "010877", "010878", "010879", "010880", "010881", "010882", "010883", "010884", "010885", "010886", "010887", "010888", "010889", "010890", "010891", "010892", "010893", "010894", "010895", "010896", "010897", "010898", "010899", "010900", "010901", "010902", "010903", "010904", "010905", "010906", "010907", "010908", "010909", "010910", "010911", "010912", "010913", "010914", "010915", "010916", "010917", "010918", "010919", "010920", "010921", "010922", "010923", "010924", "010925", "010926", "010927", "010928", "010929", "010930", "010931", "010932", "010933", "010934", "010935", "010936", "010937", "010938", "010939", "010940", "010941", "010942", "010943", "010944", "010945", "010946", "010947", "010948", "010949", "010950", "010951", "010952", "010953", "010954", "010955", "010956", "010957", "010958", "010959", "010960", "010961", "010962", "010963", "010964", "010965", "010966", "010967", "010968", "010969", "010970", "010971", "010972", "010973", "010974", "010975", "010976", "010977", "010978", "010979", "010980", "010981", "010982", "010983", "010984", "010985", "010986", "010987", "010988", "010989", "010990", "010991", "010992", "010993", "010994", "010995", "010996", "010997", "010998", "010999", "011000", "011001", "011002", "011003", "011004", "011005", "011006", "011007", "011008", "011009", "011010", "011011", "011012", "011013", "011014", "011015", "011016", "011017", "011018", "011019", "011020", "011021", "011022", "011023", "011024", "011025", "011026", "011027", "011028", "011029", "011030", "011031", "011032", "011033", "011034", "011035", "011036", "011037", "011038", "011039", "011040", "011041", "011042", "011043", "011044", "011045", "011046", "011047", "011048", "011049", "011050", "011051", "011052", "011053", "011054", "011055", "011056", "011057", "011058", "011059", "011060", "011061", "011062", "011063", "011064", "011065", "011066", "011067", "011068", "011069", "011070", "011071", "011072", "011073", "011074", "011075", "011076", "011077", "011078", "011079", "011080", "011081", "011082", "011083", "011084", "011085", "011086", "011087", "011088", "011089", "011090", "011091", "011092", "011093", "011094", "011095", "011096", "011097", "011098", "011099", "011100", "011101", "011102", "011103", "011104", "011105", "011106", "011107", "011108", "011109", "011110", "011111", "011112", "011113", "011114", "011115", "011116", "011117", "011118", "011119", "011120", "011121", "011122", "011123", "011124", "011125", "011126", "011127", "011128", "011129", "011130", "011131", "011132", "011133", "011134", "011135", "011136", "011137", "011138", "011139", "011140", "011141", "011142", "011143", "011144", "011145", "011146", "011147", "011148", "011149", "011150", "011151", "011152", "011153", "011154", "011155", "011156", "011157", "011158", "011159", "011380", "011381", "011382", "011383", "011384", "011385", "011386", "011387", "011388", "011389", "011390", "011391", "011392", "011393", "011394", "011395", "011396", "011397", "011398", "011399", "011400", "011401", "011402", "011403", "011404", "011405", "011406", "011407", "011408", "011409", "011410", "011411", "011412", "011413", "011414", "011415", "011416", "011417", "011418", "011419", "011420", "011421", "011422", "011423", "011424", "011425", "011426", "011427", "011428", "011429", "011430", "011431", "011432", "011433", "011434", "011435", "011436", "011437", "011438", "011439", "011440", "011441", "011442", "011443", "011444", "011445", "011446", "011447", "011448", "011449", "011450", "011451", "011452", "011453", "011454", "011455", "011456", "011457", "011458", "011459", "011460", "011461", "011462", "011463", "011464", "011465", "011466", "011467", "011667", "011668", "011669", "011670", "011671", "011672", "011673", "011674", "011675", "011676", "011677", "011678", "011679", "011680", "011681", "011682", "011683", "011684", "011685", "011686", "011687", "011688", "011689", "011690", "011691", "011692", "011693", "011694", "011695", "011696", "011697", "011698", "011699", "011700", "011701", "011702", "011703", "011704", "011705", "011706", "011707", "011708", "011709", "011710", "011711", "011712", "011713", "011714", "011715", "011716", "011717", "011718", "011719", "011720", "011721", "011722", "011723", "011724", "011725", "011726", "011727", "011728", "011729", "011730", "011731", "011732", "011733", "011734", "011735", "011736", "011737", "011738", "011739", "011740", "011741", "011742", "011743", "011744", "011745", "011746", "011747", "011748", "011749", "011750", "011751", "011752", "011753", "011754", "011755", "011756", "011757", "011758", "011759", "011760", "011761", "011762", "011763", "011764", "011765", "011766", "011767", "011768", "011769", "011770", "011771", "011772", "011773", "011774", "011775", "011776", "011777", "011778", "011779", "011780", "011781", "011782", "011783", "011784", "011785", "011786", "011787", "011788", "011789", "011790", "011791", "011792", "011793", "011794", "011795", "011796", "011797", "011798", "011799", "011800", "011801", "011802", "011803", "011804", "011805", "011806", "011807", "011808", "011809", "011810", "011811", "011812", "011813", "011814", "011815", "011816", "011817", "011818", "011819", "011820", "011821", "011822", "011823", "011824", "011825", "011826", "011827", "011828", "011829", "011830", "011831", "011832", "011833", "011834", "011835", "011836", "011837", "011838", "011839", "011840", "011841", "011842", "011843", "011844", "011845", "011846", "011847", "011848", "011849", "011850", "011851", "011852", "011853", "011854", "011855", "011856", "011857", "011858", "011859", "011860", "011861", "011862", "011863", "011864", "013157", "013158", "013159", "013160", "013161", "013162", "013163", "013164", "013165", "013166", "013167", "013168", "013169", "013170", "013171", "013172", "013173", "013174", "013175", "013176", "013177", "013178", "013179", "013180", "013181", "013182", "013183", "013184", "013185", "013186", "013187", "013188", "013189", "013190", "013191", "013192", "013193", "013194", "013195", "013196", "013197", "013198", "013199", "013200", "013201", "013202", "013203", "013204", "013205", "013206", "013207", "013208", "013209", "013210", "013211", "013212", "013213", "013214", "013215", "013216", "013217", "013218", "013219", "013220", "013221", "013222", "013223", "013224", "013225", "013226", "013227", "013228", "013229", "013230", "013231", "013232", "013233", "013234", "013235", "013236", "013237", "013238", "013239", "013240", "013241", "013242", "013243", "013244", "013245", "013246", "013247", "013248", "013249", "013250", "013251", "013252", "013253", "013254", "013255", "013256", "013257", "013258", "013259", "013260", "013261", "013262", "013263", "013264", "013265", "013266", "013267", "013268", "013269", "013270", "013271", "013272", "013273", "013274", "013275", "013276", "013277", "013278", "013279", "013280", "013281", "013282", "013283", "013284", "013285", "013286", "013287", "013288", "013289", "013290", "013291", "013292", "013293", "013294", "013295", "013296", "013297", "013298", "013299", "013300", "013301", "013302", "013303", "013304", "013305", "013306", "013307", "013308", "013309", "013310", "013311", "013312", "013313", "013314", "013315", "013316", "013317", "013318", "013319", "013320", "013321", "013322", "013323", "013324", "013325", "013326", "013327", "013328", "013329", "013330", "013331", "013332", "013333", "013334", "013335", "013336", "013337", "013338", "013339", "013340", "013341", "013342", "013343", "013344", "013345", "013346", "013347", "013348", "013349", "013350", "013351", "013352", "013353", "013354", "013355", "013356", "013357", "013358", "013359", "013360", "013361", "013362", "013363", "013364", "013365", "013366", "013367", "013368", "013369", "013370", "013371", "013372", "013373", "013374", "013523", "013524", "013525", "013526", "013527", "013528", "013529", "013530", "013531", "013532", "013533", "013534", "013535", "013536", "013537", "013538", "013539", "013540", "013541", "013542", "013543", "013544", "013545", "013546", "013547", "013548", "013549", "013550", "013551", "013552", "013553", "013554", "013555", "013556", "013557", "013558", "013559", "013560", "013561", "013562", "013563", "013564", "013565", "013566", "013567", "013568", "013569", "013570", "013571", "013572", "013573", "013574", "013575", "013576", "013577", "013578", "013579", "013580", "013581", "013582", "013583", "013584", "013585", "013586", "013587", "013588", "013589", "013590", "013591", "013592", "013593", "013594", "013595", "013596", "013597", "013598", "013599", "013600", "013601", "013602", "013603", "013604", "013605", "013606", "013607", "013608", "013609", "013610", "013611", "013612", "013613", "013614", "013615", "013616", "013617", "013618", "013619", "013620", "013621", "013622", "013623", "013624", "013625", "013626", "013627", "013628", "013629", "013630", "013631", "013632", "013633", "013634", "013635", "013636", "013637", "013638", "013639", "013640", "013641", "013642", "013643", "013644", "013645", "013646", "013647", "013648", "013649", "013650", "013651", "013652", "013653", "013654", "013655", "013656", "013657", "013658", "013659", "013660", "013661", "013662", "013663", "013664", "013665", "013666", "013667", "013668", "013669", "013670", "013671", "013672", "013673", "013674", "013675", "013676", "013677", "013678", "013679", "013680", "013681", "013682", "013683", "013684", "013685", "013686", "013687", "013688", "013689", "013690", "013691", "013692", "013693", "013694", "013695", "013696", "013697", "013698", "013699", "013700", "013701", "013702", "013703", "013704", "013705", "013706", "013707", "013708", "013709", "013710", "013711", "013712", "013713", "013714", "013715", "013716", "013717", "013718", "013719", "013815", "013816", "013817", "013818", "013819", "013820", "013821", "013822", "013823", "013824", "013825", "013826", "013827", "013828", "013829", "013830", "013831", "013832", "013833", "013834", "013835", "013836", "013837", "013838", "013839", "013840", "013841", "013842", "013843", "013844", "013845", "013846", "013847", "013848", "013849", "013850", "013851", "013852", "013853", "013854", "013855", "013856", "013857", "014756", "014757", "014758", "014759", "014760", "014761", "014762", "014763", "014764", "014765", "014766", "014767", "014768", "014769", "014770", "014771", "014772", "014773", "014774", "014775", "014776", "014777", "014778", "014779", "014780", "014781", "014782", "014783", "014784", "014785", "014786", "014787", "014788", "014789", "014790", "014791", "014792", "014793", "014794", "014795", "014796", "014797", "014798", "014799", "014800", "014801", "014802", "014803", "014804", "014805", "014806", "014807", "014808", "014809", "014810", "014811", "014812", "014813", "014814", "014815", "014816", "014817", "014818", "014819", "014820", "014821", "014822", "014823", "014824", "014825", "014826", "014827", "014828", "014829", "014830", "014831", "014832", "014833", "014834", "014835", "014836", "014837", "014838", "014839", "014840", "014841", "014842", "014843", "014844", "014845", "014846", "014847", "014848", "014849", "014850", "014851", "014852", "014853", "014854", "014855", "014856", "014857", "014858", "014859", "014860", "014861", "014862", "014863", "014864", "014865", "014866", "014867", "014868", "014869", "014870", "014871", "014872", "014873", "014874", "014875", "014876", "014877", "014878", "014879", "014880", "014881", "014882", "014883", "014884", "014885", "014886", "014887", "014888", "014889", "014890", "014891", "014892", "014893", "014894", "014895", "014896", "014897", "014898", "014899", "014900", "014901", "014902", "014903", "014904", "014905", "014906", "014907", "014908", "014909", "014910", "014911", "014912", "014913", "014914", "014915", "014916", "014917", "014918", "014919", "014920", "014921", "014922", "014923", "014924", "014925", "014926", "014927", "014928", "014929", "014930", "014931", "014932", "014933", "014934", "014935", "014936", "014937", "014938", "014939", "014940", "014941", "014942", "014943", "014944", "014945", "014946", "014947", "014948", "014949", "014950", "014951", "014952", "014953", "014954", "014955", "014956", "014957", "014958", "014959", "014960", "014961", "014962", "014963", "014964", "014965", "014966", "014967", "014968", "014969", "014970", "014971", "014972", "014973", "014974", "014975", "014976", "014977", "014978", "014979", "014980", "014981", "014982", "014983", "014984", "014985", "014986", "014987", "014988", "014989", "014990", "014991", "014992", "014993", "014994", "014995", "015018", "015019", "015020", "015021", "015022", "015023", "015024", "015025", "015026", "015027", "015028", "015029", "015030", "015031", "015032", "015033", "015034", "015035", "015036", "015037", "015038", "015039", "015040", "015041", "015042", "015043", "015044", "015045", "015046", "015047", "015048", "015049", "015050", "015051", "015052", "015053", "015054", "015055", "015056", "015057", "015058", "015059", "015060", "015061", "015062", "015063", "015064", "015065", "015066", "015067", "015068", "015069", "015070", "015071", "015072", "015073", "015074", "015075", "015076", "015077", "015078", "015079", "015080", "015081", "015082", "015083", "015084", "015085", "015086", "015087", "015088", "015089", "015090", "015091", "015092", "015093", "015094", "015095", "015096", "015097", "015098", "015099", "015100", "015101", "015102", "015103", "015104", "015105", "015106", "015107", "015108", "015109", "015110", "015111", "015112", "015113", "015114", "015115", "015116", "015117", "015118", "015119", "015120", "015121", "015122", "015123", "015124", "015125", "015126", "015127", "015128", "015129", "015130", "015131", "015132", "015133", "015134", "015135", "015136", "015137", "015138", "015139", "015140", "015141", "015142", "015143", "015144", "015145", "015146", "015147", "015148", "015149", "015150", "015151", "015152", "015153", "015154", "015155", "015156", "015157", "015158", "015159", "015160", "015161", "015162", "015163", "015164", "015165", "015166", "015167", "015168", "015169", "015170", "015171", "015172", "015173", "015174", "015175", "015176", "015177", "015178", "015179", "015180", "015181", "015182", "015183", "015184", "015185", "015186", "015187", "015188", "015189", "015190", "015191", "015192", "015193", "015194", "015195", "015196", "015197", "015198", "015199", "015200", "015201", "015202", "015203", "015204", "015205", "015206", "015207", "015208", "015209", "015210", "015211", "015212", "015213", "015214", "015215", "015216", "015217", "015218", "015219", "015220", "015221", "015222", "015223", "015224", "015225", "015226", "015227", "015228", "015229", "015230", "015231", "015232", "015233", "015234", "015235", "015236", "015237", "015238", "015239", "015240", "015241", "015242", "015243", "015244", "015245", "015246", "015247", "015248", "015249", "015250", "015251", "015252", "015253", "015640", "015641", "015642", "015643", "015644", "015645", "015646", "015647", "015648", "015649", "015650", "015651", "015652", "015653", "015654", "015655", "015656", "015657", "015658", "015659", "015660", "015661", "015662", "015663", "015664", "015665", "015666", "015667", "015668", "015669", "015670", "015671", "015672", "015673", "015674", "015675", "015676", "015677", "015678", "015679", "015680", "015681", "015682", "015683", "015684", "015685", "015686", "015687", "015688", "015689", "015690", "015691", "015692", "015693", "015694", "015695", "015696", "015697", "015698", "015699", "015700", "015701", "015702", "015703", "015704", "015705", "015706", "015707", "015708", "015709", "015710", "015711", "015712", "015713", "015714", "015715", "015716", "015717", "015718", "015719", "015720", "015721", "015722", "015723", "015724", "015725", "015726", "015727", "015728", "015729", "015730", "015731", "015732", "015733", "015734", "015735", "015736", "015737", "015738", "015739", "015740", "015741", "015742", "015743", "015744", "015745", "015746", "015747", "015748", "015749", "015750", "015751", "015756", "015757", "015758", "015759", "015760", "015761", "015762", "015763", "015764", "015765", "015766", "015767", "015768", "015769", "015770", "015771", "015772", "015773", "015774", "015775", "015776", "015777", "015778", "015779", "015780", "015781", "015782", "015783", "015784", "015785", "015786", "015787", "015788", "015789", "015790", "015791", "015792", "015793", "015794", "015795", "015796", "015797", "015798", "015799", "015800", "015801", "015802", "015803", "015804", "015805", "015806", "015807", "015808", "015809", "015810", "015811", "015812", "015813", "015814", "015815", "015816", "015817", "015818", "015819", "015820", "015821", "015822", "015823", "015824", "015825", "015826", "015827", "015828", "015829", "015830", "015831", "015832", "015833", "015834", "015835", "015836", "015837", "015838", "015839", "015840", "015841", "015842", "015843", "015844", "015845", "015846", "015847", "015848", "015849", "015850", "015851", "015852", "015853", "015854", "015855", "015856", "015857", "015858", "015859", "015860", "015861", "015862", "015863", "015864", "015865", "015866", "015867", "015868", "015869", "015870", "015871", "015872"], "test": ["001581", "001582", "001583", "001584", "001585", "001586", "001587", "001588", "001589", "001590", "001591", "001592", "001593", "001594", "001595", "001596", "001597", "001598", "001599", "001600", "001601", "001602", "001603", "001605", "001606", "001607", "001608", "001609", "001610", "001611", "001612", "001614", "001615", "001616", "001617", "001618", "001619", "001620", "001621", "001622", "001623", "001624", "001625", "001626", "001627", "001628", "001629", "001630", "001631", "001632", "001633", "001634", "001635", "001636", "001637", "001638", "001639", "001640", "001641", "001642", "001643", "001644", "001645", "001646", "001647", "001648", "001649", "001650", "001651", "001652", "001653", "001654", "001655", "001656", "001657", "001658", "001659", "001661", "001662", "001663", "001664", "001665", "001666", "001667", "001668", "001669", "001670", "001671", "001672", "001673", "001674", "001675", "001676", "001677", "001678", "001679", "001680", "001681", "001682", "001683", "001684", "001685", "001686", "001687", "001688", "001689", "001690", "001691", "001692", "001693", "001694", "001695", "001696", "001697", "001698", "001699", "001700", "001701", "001702", "001703", "001704", "001705", "001706", "001707", "001708", "001709", "001710", "001711", "001712", "001713", "001714", "001715", "001716", "001717", "001718", "001719", "001720", "001721", "001722", "001723", "001724", "001725", "001726", "001727", "001728", "001729", "001730", "001731", "001732", "001733", "001734", "001735", "001736", "001737", "001738", "001739", "001740", "001741", "001742", "001743", "001744", "001745", "001746", "001747", "001748", "001749", "001750", "001751", "001752", "001753", "001754", "001755", "001756", "001757", "001758", "001759", "001760", "001761", "001762", "001763", "001764", "001765", "001766", "001767", "001768", "001769", "001770", "001771", "001772", "001773", "001774", "001775", "001776", "001777", "001778", "001779", "001780", "001781", "001782", "001783", "001784", "001785", "001786", "002160", "002161", "002162", "002163", "002164", "002165", "002166", "002167", "002168", "002169", "002170", "002171", "002172", "002173", "002174", "002175", "002176", "002177", "002178", "002179", "002180", "002181", "002182", "002183", "002184", "002185", "002186", "002187", "002188", "002189", "002190", "002191", "002192", "002193", "002194", "002195", "002196", "002197", "002198", "002199", "002200", "002201", "002202", "002203", "002204", "002205", "002206", "002207", "002208", "002209", "002210", "002211", "002212", "002213", "002214", "002215", "002216", "002217", "002218", "002219", "002220", "002221", "002222", "002223", "002224", "002225", "002226", "002227", "002228", "002229", "002230", "002231", "002232", "002233", "002234", "002235", "002236", "002237", "002238", "002239", "002240", "002241", "002242", "002243", "002244", "002245", "002246", "002247", "002248", "002249", "002250", "002251", "002252", "002253", "002254", "002255", "002256", "002257", "002258", "002259", "002260", "002261", "002262", "002263", "002264", "002265", "002266", "002267", "002268", "002269", "002270", "002271", "002272", "002273", "002274", "002275", "002276", "002277", "002278", "002279", "002280", "002281", "002282", "002283", "002284", "002285", "002286", "002287", "002288", "002289", "002290", "002291", "002292", "002293", "002294", "002295", "002296", "002297", "002298", "002299", "002300", "002301", "002302", "002303", "002304", "002305", "002306", "002307", "002308", "002309", "002310", "002311", "002312", "002313", "002314", "002315", "002316", "002317", "002318", "002319", "002320", "002321", "002322", "002323", "002324", "002325", "002326", "002327", "002328", "002329", "002330", "002331", "002332", "002333", "002334", "002335", "002336", "002337", "002338", "002339", "002340", "002341", "002342", "002534", "002535", "002536", "002537", "002538", "002539", "002540", "002541", "002542", "002543", "002544", "002545", "002546", "002547", "002548", "002549", "002550", "002551", "002552", "002553", "002554", "002555", "002556", "002557", "002558", "002559", "002560", "002561", "002562", "002563", "002564", "002565", "002566", "002567", "002568", "002569", "002570", "002571", "002572", "002573", "002574", "002575", "002576", "002577", "002578", "002579", "002580", "002581", "002582", "002583", "002584", "002585", "002586", "002587", "002588", "002589", "002590", "002591", "002592", "002593", "002594", "002595", "002596", "002597", "002598", "002599", "002600", "002601", "002602", "002603", "002604", "002605", "002606", "002607", "002608", "002609", "002610", "002611", "002612", "002613", "002614", "002615", "002616", "002617", "002618", "002619", "002620", "002621", "002622", "002623", "002624", "002625", "002626", "002627", "002628", "002629", "002630", "002631", "002632", "002633", "002634", "002635", "002636", "002637", "002638", "002639", "002640", "002641", "002642", "002643", "002644", "002645", "002646", "002647", "002648", "002649", "002650", "002651", "002652", "002653", "002654", "002655", "002656", "002657", "002658", "002659", "002660", "002661", "002662", "002663", "002664", "002665", "002666", "002667", "002668", "002669", "002670", "002671", "002672", "002673", "002674", "002675", "002676", "002677", "002678", "002679", "002680", "002681", "002682", "002683", "002684", "002685", "002686", "002687", "002688", "002689", "002690", "002691", "002692", "002693", "002694", "002695", "002696", "002697", "002698", "002699", "002700", "002701", "002702", "002703", "002704", "002705", "002706", "002707", "002708", "002709", "002710", "002711", "002712", "002713", "002715", "002716", "002717", "002718", "002719", "002720", "002721", "002722", "002723", "002724", "002725", "002726", "002727", "002728", "002729", "002730", "002731", "002732", "002733", "002734", "002735", "002736", "002737", "002738", "002739", "002740", "002741", "002742", "002743", "002744", "002745", "002746", "002747", "002748", "002749", "002750", "002751", "002752", "002753", "002754", "002755", "002756", "002757", "002758", "002759", "002760", "002761", "002762", "002763", "002764", "002765", "002766", "002767", "002768", "002769", "002770", "002771", "002772", "002773", "002774", "002775", "002776", "002777", "002778", "002779", "002780", "002781", "002782", "002783", "002784", "002785", "002786", "002787", "002788", "002789", "002790", "002791", "002792", "002793", "002794", "002795", "002796", "002797", "002798", "002799", "002800", "002801", "002802", "002803", "002804", "002805", "002806", "002807", "002808", "002809", "002810", "002811", "002812", "002813", "002814", "002815", "002816", "002817", "002818", "002819", "002820", "002821", "002822", "002823", "002824", "002825", "002826", "002827", "002828", "002829", "002830", "002831", "002832", "002833", "002834", "002835", "002836", "002837", "002838", "002839", "002840", "002841", "002842", "002843", "002844", "002845", "002846", "002847", "002848", "002849", "002850", "002851", "002852", "002853", "002854", "002855", "002856", "002857", "002858", "002859", "002860", "002861", "002862", "002863", "002864", "002865", "002866", "002867", "002868", "002869", "002870", "002871", "002872", "002873", "002874", "002875", "002876", "002877", "002878", "002879", "002880", "002881", "002882", "002883", "002884", "002885", "002886", "002887", "002888", "002889", "002890", "002891", "002892", "002893", "002894", "002895", "002896", "002897", "002898", "002899", "002900", "002901", "002902", "002903", "002904", "002905", "002906", "002907", "002908", "002909", "002910", "002911", "002912", "002913", "002914", "002915", "002916", "002917", "002918", "002919", "002920", "002921", "002922", "002923", "002924", "002925", "002926", "002927", "002928", "002929", "002930", "002931", "002932", "002933", "002934", "002935", "002936", "002937", "002938", "002939", "002940", "002941", "002942", "002943", "002944", "002945", "002946", "002947", "002948", "002949", "002950", "002951", "002952", "002953", "002954", "002955", "002956", "002957", "002958", "002959", "002960", "002961", "002962", "002963", "002964", "002965", "002966", "002967", "002968", "002969", "002970", "002971", "002972", "002973", "002974", "002975", "002976", "002977", "002978", "002979", "002980", "002981", "002982", "002983", "002984", "002985", "002986", "002987", "002988", "002989", "002990", "002991", "002992", "002993", "002994", "002995", "002996", "002997", "002998", "002999", "003000", "003001", "003002", "003003", "003004", "003005", "003006", "003007", "003008", "003009", "003010", "003011", "003012", "003013", "003014", "003015", "003016", "003017", "003018", "003790", "003791", "003792", "003793", "003794", "003795", "003796", "003797", "003798", "003799", "003800", "003801", "003802", "003803", "003804", "003805", "003806", "003807", "003808", "003809", "003810", "003811", "003812", "003813", "003814", "003815", "003816", "003817", "003818", "003819", "003820", "003821", "003822", "003823", "003824", "003825", "003826", "003827", "003828", "003829", "003830", "003831", "003832", "003833", "003834", "003835", "003836", "003837", "003838", "003839", "003840", "003841", "003842", "003843", "003844", "003845", "003846", "003847", "003848", "003849", "003850", "003851", "003852", "003853", "003854", "003855", "003856", "003857", "003858", "003859", "003860", "003861", "003862", "003863", "003864", "003865", "003866", "003867", "003868", "003869", "003870", "003871", "003872", "003873", "003874", "003875", "003876", "003877", "003878", "003879", "003880", "003881", "003882", "003883", "003884", "003885", "003886", "003887", "003888", "003889", "003890", "003891", "003892", "003893", "003894", "003895", "003896", "003897", "003898", "003899", "003900", "003901", "003902", "003903", "003904", "003905", "003906", "003907", "003908", "003909", "003910", "003911", "003912", "003913", "003914", "003915", "003916", "003917", "003918", "003919", "003920", "003921", "003922", "003923", "003924", "003925", "003926", "003927", "003928", "003929", "003930", "003931", "003932", "003933", "003934", "003935", "003936", "003937", "003938", "003939", "003940", "003941", "003942", "003943", "003944", "003945", "003946", "003947", "003948", "003949", "003950", "003951", "003952", "003953", "003954", "003955", "003956", "003957", "003958", "003959", "003960", "003961", "003962", "003963", "003964", "003965", "003966", "003967", "003968", "003969", "003970", "003971", "003972", "003973", "003974", "003975", "003976", "003977", "003978", "003979", "003980", "003981", "003982", "003983", "003984", "003985", "003986", "003987", "003988", "003989", "003990", "003991", "003992", "003993", "003994", "003995", "003996", "003997", "003998", "003999", "004000", "004001", "004002", "004003", "004004", "004005", "004006", "004007", "004008", "004009", "004010", "004011", "004012", "004719", "004720", "004721", "004722", "004723", "004724", "004725", "004726", "004727", "004728", "004729", "004730", "004731", "004732", "004733", "004734", "004735", "004736", "004737", "004738", "004739", "004740", "004741", "004742", "004743", "004744", "004745", "004746", "004747", "004748", "004749", "004750", "004751", "004752", "004753", "004754", "004755", "004756", "004757", "004758", "004759", "004760", "004761", "004762", "004763", "004764", "004765", "004766", "004767", "004768", "004769", "004770", "004771", "004772", "004773", "004774", "004775", "004776", "004777", "004778", "004779", "004780", "004781", "004782", "004783", "004784", "004785", "004786", "004787", "004788", "004789", "004790", "004791", "004792", "004793", "004794", "004795", "004796", "004797", "004798", "004799", "004800", "004801", "004802", "004803", "004804", "004805", "004806", "004807", "004808", "004809", "004810", "004811", "004812", "004813", "004814", "004815", "004816", "004817", "004818", "004819", "004820", "004821", "004822", "004823", "004824", "004825", "004826", "004827", "004828", "004829", "004830", "004831", "004832", "004833", "004834", "004835", "004836", "004837", "004838", "004839", "004840", "004841", "004842", "004843", "004844", "004845", "004846", "004847", "004848", "004849", "004850", "004851", "004852", "004853", "004854", "004855", "004856", "004857", "004858", "004859", "005052", "005053", "005054", "005055", "005056", "005057", "005058", "005059", "005060", "005061", "005062", "005063", "005064", "005065", "005066", "005067", "005068", "005069", "005070", "005071", "005072", "005073", "005074", "005075", "005076", "005077", "005078", "005079", "005080", "005081", "005082", "005083", "005084", "005085", "005086", "005087", "005088", "005089", "005090", "005091", "005092", "005093", "005094", "005095", "005096", "005097", "005098", "005099", "005100", "005101", "005102", "005103", "005104", "005105", "005106", "005107", "005108", "005109", "005110", "005111", "005112", "005113", "005114", "005115", "005116", "005117", "005118", "005119", "005120", "005121", "005122", "005123", "005124", "005125", "005126", "005127", "005128", "005129", "005130", "005131", "005132", "005133", "005134", "005135", "005136", "005137", "005138", "005139", "005140", "005141", "005142", "005143", "005144", "005145", "005146", "005147", "005148", "005149", "005150", "005151", "005152", "005153", "005154", "005155", "005156", "005157", "005158", "005159", "005160", "005161", "005162", "005163", "005164", "005165", "005166", "005167", "005168", "005169", "005170", "005171", "005172", "005173", "005174", "005175", "005176", "005177", "005178", "005179", "005180", "005181", "005182", "005183", "005184", "005185", "005186", "005187", "005188", "005189", "005190", "005191", "005192", "005193", "005194", "005195", "005196", "005197", "005198", "005199", "005200", "005201", "005202", "005203", "005204", "005205", "005206", "005207", "005208", "005209", "005210", "005211", "005212", "005213", "005214", "005215", "005216", "005217", "005218", "005219", "005220", "005221", "005222", "005223", "005224", "005225", "005226", "005227", "005228", "005229", "005230", "005231", "005232", "005233", "005234", "005235", "005236", "005237", "005238", "005239", "005240", "005241", "005242", "005243", "005244", "005245", "005246", "005247", "005248", "005249", "005250", "005251", "005252", "005253", "005254", "005255", "005256", "005257", "005258", "005259", "005260", "005261", "005262", "005263", "005264", "005265", "005266", "005267", "005268", "005269", "005270", "005271", "005272", "005273", "005274", "005275", "005276", "005277", "005278", "005279", "005280", "005281", "005282", "005283", "005284", "005285", "005286", "005287", "005288", "005289", "005290", "005291", "005292", "005293", "005294", "005295", "005296", "005297", "005298", "005299", "005300", "005301", "005302", "005303", "005304", "005305", "005306", "005307", "005308", "005309", "005310", "005311", "005312", "005313", "005314", "005315", "005316", "005317", "005318", "005319", "005320", "005321", "005322", "005323", "005324", "005325", "005326", "005327", "005328", "005329", "005330", "005331", "005332", "005333", "005334", "005335", "005336", "005337", "005338", "005339", "005340", "005341", "005342", "005343", "005344", "005345", "005346", "005347", "005348", "005349", "005350", "005351", "005352", "005353", "005354", "005355", "005356", "005357", "005358", "005359", "005360", "005361", "005362", "005363", "005364", "005365", "005366", "005367", "005368", "005369", "005370", "005371", "005372", "005373", "005374", "005375", "005376", "005377", "005378", "005379", "005380", "005381", "005382", "005383", "005384", "005385", "005386", "005387", "005388", "005389", "005390", "005391", "005392", "005393", "005394", "005395", "005396", "005397", "005398", "005399", "005400", "005401", "005402", "005403", "005404", "005405", "005406", "005407", "005408", "005409", "005410", "005411", "005412", "005413", "005414", "005415", "005416", "005417", "005418", "005419", "005420", "005421", "005422", "005423", "005424", "005425", "005426", "005427", "005428", "005429", "005430", "005431", "005432", "005433", "005434", "005435", "005436", "005437", "005438", "005439", "005440", "005441", "005442", "005443", "005444", "005445", "005446", "005447", "005448", "005449", "005450", "005451", "005452", "005453", "005454", "005455", "005456", "005457", "005458", "005459", "005460", "005461", "005462", "005463", "005464", "005465", "005466", "005467", "005468", "005469", "005470", "005471", "005472", "005473", "005474", "005475", "005476", "005477", "005478", "005479", "005480", "005481", "005482", "005483", "005484", "005485", "005486", "005487", "005488", "005489", "005490", "005491", "005492", "005493", "005494", "005495", "005496", "005497", "005498", "005499", "005500", "005501", "005502", "005503", "005504", "005505", "005506", "005507", "005508", "005509", "005510", "005511", "005512", "005513", "005514", "005515", "005516", "005517", "005518", "005519", "005520", "005521", "005522", "005523", "005524", "005525", "005526", "005527", "005528", "005529", "005530", "005531", "005532", "005533", "005534", "005535", "005536", "005537", "005538", "005539", "005540", "005541", "005542", "005543", "005544", "005545", "005546", "005547", "005548", "005549", "005550", "005551", "005552", "005553", "005554", "005555", "005556", "005557", "005558", "005559", "005560", "005561", "005562", "005563", "005564", "005565", "005566", "005567", "005568", "005569", "005570", "005571", "005572", "005573", "005574", "005575", "005576", "005577", "005578", "005579", "005580", "005581", "005582", "005583", "005584", "005585", "005586", "005920", "005921", "005922", "005923", "005924", "005925", "005926", "005927", "005928", "005929", "005930", "005931", "005932", "005933", "005934", "005935", "005936", "005937", "005938", "005939", "005940", "005941", "005942", "005943", "005944", "005945", "005946", "005947", "005948", "005949", "005950", "005951", "005952", "005953", "005954", "005955", "005956", "005957", "005958", "005959", "005960", "005961", "005962", "005963", "005964", "005965", "005966", "005967", "005968", "005969", "005970", "005971", "005972", "005973", "005974", "005975", "005976", "005977", "005978", "005979", "005980", "005981", "005982", "005983", "005984", "005985", "005986", "005987", "005988", "005989", "005990", "005991", "005992", "005993", "005994", "005995", "005996", "005997", "005998", "005999", "006000", "006001", "006002", "006003", "006004", "006005", "006006", "006007", "006008", "006009", "006010", "006011", "006012", "006013", "006014", "006015", "006016", "006017", "006018", "006019", "006020", "006021", "006022", "006023", "006024", "006025", "006026", "006027", "006028", "006029", "006030", "006031", "006032", "006033", "006034", "006035", "006036", "006037", "006038", "006039", "006040", "006041", "006042", "006043", "006044", "006045", "006046", "006047", "006048", "006049", "006050", "006051", "006052", "006053", "006054", "006055", "006056", "006057", "006058", "006059", "006060", "006061", "006062", "006063", "006064", "006065", "006066", "006067", "006068", "006069", "006070", "006071", "006072", "006073", "006074", "006075", "006076", "006077", "006078", "006079", "006080", "006081", "006082", "006083", "006084", "006085", "006086", "006087", "006088", "006089", "006090", "006091", "006092", "006093", "006094", "006095", "006096", "006097", "006098", "006099", "006100", "006101", "007008", "007009", "007010", "007011", "007012", "007013", "007014", "007015", "007016", "007017", "007018", "007019", "007020", "007021", "007022", "007023", "007024", "007025", "007026", "007027", "007028", "007029", "007030", "007031", "007032", "007033", "007034", "007035", "007036", "007037", "007038", "007039", "007040", "007041", "007042", "007043", "007044", "007045", "007046", "007047", "007048", "007049", "007050", "007051", "007052", "007053", "007054", "007055", "007056", "007057", "007058", "007059", "007060", "007061", "007062", "007063", "007064", "007065", "007066", "007067", "007068", "007069", "007070", "007071", "007072", "007073", "007074", "007075", "007076", "007077", "007078", "007079", "007080", "007081", "007082", "007083", "007084", "007085", "007086", "007087", "007088", "007089", "007090", "007091", "007092", "007093", "007094", "007095", "007096", "007097", "007098", "007099", "007100", "007101", "007102", "007103", "007104", "007105", "007106", "007107", "007108", "007109", "007110", "007111", "007112", "007113", "007114", "007115", "007116", "007117", "007118", "007119", "007120", "007121", "007122", "007123", "007124", "007125", "007126", "007127", "007128", "007129", "007130", "007131", "007132", "007133", "007134", "007135", "007136", "007137", "007138", "007139", "007140", "007141", "007142", "007143", "007144", "007145", "007146", "007147", "007148", "007149", "007150", "007151", "007152", "007153", "007154", "007155", "007156", "007157", "007158", "007159", "007160", "007161", "007162", "007163", "007164", "007165", "007166", "007167", "007168", "007169", "007170", "007171", "007172", "007173", "007174", "007175", "007176", "007177", "007178", "007179", "007180", "007181", "007182", "007183", "007184", "007185", "007186", "007187", "007188", "007189", "007190", "007191", "007192", "007193", "007194", "007195", "007196", "007197", "007198", "007199", "007200", "007201", "007202", "007203", "007204", "007205", "007206", "007207", "007208", "007209", "007210", "007211", "007212", "007213", "007214", "007215", "007216", "007217", "007218", "007219", "007220", "007221", "007222", "007223", "007224", "007225", "007226", "007227", "007228", "007229", "007230", "007231", "007232", "007233", "007234", "007235", "007236", "007237", "007238", "007239", "007240", "007241", "007242", "007243", "007244", "007245", "007246", "007247", "007248", "007249", "007250", "007251", "007252", "007253", "007254", "007255", "007256", "007257", "007258", "007259", "007260", "007261", "007262", "007263", "007264", "007265", "007266", "007267", "007268", "007269", "007270", "007271", "007272", "007273", "007274", "007275", "007276", "007277", "007278", "007279", "007280", "007281", "007282", "007283", "007284", "007285", "007286", "007287", "007288", "007289", "007290", "007291", "007292", "007293", "007294", "007295", "007296", "007297", "007298", "007299", "007300", "007301", "007302", "007303", "007304", "007305", "007306", "007307", "007308", "007309", "007310", "007311", "007312", "007313", "007314", "007315", "007316", "007317", "007318", "007319", "007320", "007321", "007322", "007323", "007324", "007325", "007326", "007327", "007328", "007329", "007330", "007331", "007332", "007333", "007334", "007335", "007336", "007337", "007338", "007339", "007340", "007341", "007342", "007343", "007344", "007345", "007346", "007347", "007348", "007349", "007350", "007351", "007352", "007353", "007354", "007355", "007356", "007357", "007358", "007359", "007360", "007361", "007362", "007363", "007364", "007365", "007366", "007367", "007368", "007369", "007370", "007371", "007372", "007373", "007374", "007375", "007376", "007377", "007378", "007379", "007380", "007381", "007382", "007383", "007384", "007385", "007386", "007387", "007388", "007389", "007390", "007391", "007392", "007393", "007394", "007395", "007396", "007397", "007398", "007399", "007400", "007401", "007402", "007403", "007404", "007405", "007406", "007407", "007408", "007409", "007410", "007411", "007412", "007413", "007414", "007415", "007416", "007417", "007418", "007419", "007420", "007421", "007422", "007423", "007424", "007425", "007426", "007427", "007428", "007429", "007430", "007431", "007432", "007433", "007434", "007435", "007436", "007437", "007438", "007439", "007440", "007441", "007442", "007443", "007444", "007445", "007446", "007447", "007988", "007989", "007990", "007991", "007992", "007993", "007994", "007995", "007996", "007997", "007998", "007999", "008000", "008001", "008002", "008003", "008004", "008005", "008006", "008007", "008008", "008009", "008010", "008011", "008012", "008013", "008014", "008015", "008016", "008017", "008018", "008019", "008020", "008021", "008022", "008023", "008024", "008025", "008026", "008027", "008028", "008029", "008030", "008031", "008032", "008033", "008034", "008035", "008036", "008037", "008038", "008039", "008040", "008041", "008042", "008043", "008044", "008045", "008046", "008047", "008048", "008049", "008050", "008051", "008052", "008053", "008054", "008055", "008056", "008057", "008058", "008059", "008060", "008061", "008062", "008063", "008064", "008065", "008066", "008067", "008068", "008069", "008070", "008071", "008072", "008073", "008074", "008075", "008076", "008077", "008078", "008079", "008080", "008081", "008082", "008083", "008084", "008085", "008086", "008087", "008088", "008089", "008090", "008091", "008092", "008093", "008094", "008095", "008096", "008097", "008098", "008099", "008100", "008101", "008102", "008103", "008104", "008105", "008106", "008107", "008108", "008109", "008110", "008111", "008112", "008113", "008114", "008115", "008116", "008117", "008118", "008119", "008120", "008121", "008122", "008123", "008124", "008125", "008126", "008127", "008128", "008129", "008130", "008131", "008132", "008133", "008134", "008135", "008136", "008137", "008138", "008139", "008140", "008141", "008142", "008143", "008144", "008145", "008146", "008147", "008148", "008149", "008150", "008151", "008152", "008153", "008154", "008155", "008156", "008157", "008158", "008159", "008160", "008161", "008162", "008163", "008164", "008165", "008166", "008167", "008168", "008169", "008170", "008171", "008172", "008173", "008174", "008175", "008176", "008177", "008178", "008179", "008180", "008181", "008182", "008183", "008184", "008185", "008186", "008187", "008188", "008189", "008190", "008191", "008192", "008193", "008194", "008195", "008196", "008197", "008198", "008199", "008200", "008201", "008202", "008203", "008204", "008205", "008206", "008207", "008208", "008209", "008210", "008211", "008212", "008213", "008214", "008215", "008216", "008217", "008218", "008219", "008220", "008221", "008222", "008223", "008224", "008225", "008226", "008227", "008228", "008229", "008230", "008231", "008232", "008233", "008234", "008235", "008236", "008237", "008238", "008239", "008240", "008241", "008242", "008243", "008244", "008245", "008246", "008247", "008248", "008249", "008250", "008251", "008252", "008253", "008254", "008255", "008256", "008257", "008258", "008259", "008260", "008261", "008262", "008263", "008264", "008265", "008266", "008267", "008268", "008269", "008270", "008271", "008272", "008273", "008274", "008275", "008276", "008277", "008278", "008279", "008280", "008281", "008282", "008283", "008284", "008285", "008286", "008287", "008288", "008289", "008290", "008291", "008292", "008293", "008294", "008295", "008296", "008297", "008298", "008299", "008300", "008301", "008302", "008303", "008304", "008305", "008306", "008307", "008308", "008309", "008310", "008311", "008312", "008313", "008314", "008315", "008316", "008317", "008318", "008319", "008320", "008321", "008322", "008323", "008324", "008325", "008326", "008327", "008328", "008329", "008330", "008331", "008332", "008333", "008334", "008335", "008336", "008337", "008338", "008339", "008340", "008341", "008342", "008343", "008344", "008345", "008346", "008347", "008348", "008349", "008350", "008351", "008352", "008353", "008354", "008355", "008356", "008357", "008358", "008359", "008360", "008361", "008362", "008363", "008364", "008365", "008366", "008367", "008368", "008369", "008370", "008371", "008372", "008373", "008374", "008375", "008376", "008377", "008378", "008379", "008380", "008381", "008382", "008383", "008384", "008385", "008386", "008387", "008388", "008389", "008390", "008391", "008392", "008393", "008394", "008395", "008396", "008397", "008398", "008399", "008400", "008401", "008402", "008403", "008404", "008405", "008406", "008407", "008408", "008409", "008410", "008411", "008412", "008413", "008414", "008415", "008416", "008417", "008418", "008419", "008420", "008421", "008422", "008423", "008424", "008425", "008426", "008427", "008428", "008429", "008430", "008431", "008432", "008433", "008434", "008435", "008436", "008437", "008438", "008439", "008440", "008441", "008442", "008443", "008444", "008445", "008446", "008447", "008448", "008449", "008450", "008451", "008452", "008453", "008454", "008455", "008456", "008457", "008458", "008459", "008460", "008461", "008462", "008463", "008464", "008465", "008466", "008467", "008468", "008469", "008470", "008471", "008472", "008473", "008474", "008475", "008476", "008477", "008488", "008489", "008490", "008491", "008492", "008493", "008494", "008495", "008496", "008497", "008498", "008499", "008500", "008501", "008502", "008503", "008504", "008505", "008506", "008507", "008508", "008509", "008510", "008511", "008512", "008513", "008514", "008515", "008516", "008517", "008518", "008519", "008520", "008521", "008522", "008523", "008524", "008525", "008526", "008527", "008528", "008529", "008530", "008531", "008532", "008533", "008534", "008535", "008536", "008537", "008538", "008539", "008540", "008541", "008542", "008543", "008544", "008545", "008546", "008547", "008548", "008549", "008550", "008551", "008552", "008553", "008554", "008555", "008556", "008557", "008558", "008559", "008560", "008561", "008562", "008563", "008564", "008565", "008566", "008567", "008568", "008569", "008570", "008571", "008572", "008573", "008574", "008575", "008576", "008577", "008578", "008579", "008580", "008581", "008582", "008583", "008584", "008585", "008586", "008587", "008588", "008589", "008590", "008591", "008592", "008593", "008594", "008595", "008596", "008597", "008598", "008599", "008600", "008601", "008602", "008603", "008604", "008605", "008606", "008607", "008608", "008609", "008610", "008611", "008612", "008613", "008614", "008615", "008616", "008617", "008618", "008619", "008620", "008621", "008622", "008623", "008624", "008625", "008626", "008627", "008628", "008629", "008630", "008631", "008632", "008633", "008634", "008635", "008636", "008637", "008638", "008639", "008640", "008641", "008642", "008643", "008644", "008645", "008646", "008647", "008648", "008649", "008650", "008651", "008652", "008653", "008654", "008655", "008656", "008657", "008658", "008659", "008660", "008661", "008662", "008663", "008664", "008665", "008666", "008667", "008668", "008669", "008670", "008671", "008672", "008673", "008674", "008675", "008676", "008677", "008678", "008679", "008680", "008681", "008682", "008683", "008684", "008685", "008686", "008687", "009369", "009370", "009371", "009372", "009373", "009374", "009375", "009376", "009377", "009378", "009379", "009380", "009381", "009382", "009383", "009384", "009385", "009386", "009387", "009388", "009389", "009390", "009391", "009392", "009393", "009394", "009395", "009396", "009397", "009398", "009399", "009400", "009401", "009402", "009403", "009404", "009405", "009406", "009407", "009408", "009409", "009410", "009411", "009412", "009413", "009414", "009415", "009416", "009417", "009418", "009419", "009420", "009421", "009422", "009423", "009424", "009425", "009426", "009427", "009428", "009429", "009430", "009431", "009432", "009433", "009434", "009435", "009436", "009437", "009438", "009439", "009440", "009441", "009442", "009443", "009444", "009445", "009446", "009447", "009448", "009449", "009450", "009451", "009452", "009453", "009454", "009455", "009456", "009457", "009458", "009459", "009460", "009461", "009462", "009463", "009464", "009465", "009466", "009467", "009468", "009469", "009470", "009471", "009472", "009473", "009474", "009475", "009476", "009477", "009478", "009479", "009480", "009481", "009482", "009483", "009484", "009485", "009486", "009487", "009488", "009489", "009490", "009491", "009492", "009493", "009494", "009495", "009496", "009497", "009498", "009499", "009500", "009501", "009502", "009503", "009504", "009505", "009506", "009507", "009508", "009509", "009510", "009511", "009512", "009513", "009514", "009515", "009516", "009517", "009518", "009519", "009520", "009521", "009522", "009523", "009524", "009525", "009526", "009527", "009528", "009529", "009530", "009531", "009532", "009533", "009534", "009535", "009536", "009537", "009538", "009539", "009540", "009541", "009542", "009543", "009544", "009545", "009546", "009547", "009548", "009549", "009550", "009551", "009552", "009553", "009554", "009555", "009556", "009557", "009558", "009559", "009560", "009561", "009562", "009563", "009564", "009565", "009566", "009567", "009568", "009569", "009570", "009571", "009572", "009573", "009574", "009575", "009576", "009577", "009578", "009719", "009720", "009721", "009722", "009723", "009724", "009725", "009726", "009727", "009728", "009729", "009730", "009731", "009732", "009733", "009734", "009735", "009736", "009737", "009738", "009739", "009740", "009741", "009742", "009743", "009744", "009745", "009746", "009747", "009748", "009749", "009750", "009751", "009752", "009753", "009754", "009755", "009756", "009757", "009758", "009759", "009760", "009761", "009762", "009763", "009764", "009765", "009766", "009767", "009768", "009769", "009770", "009771", "009772", "009773", "009774", "009775", "009776", "009777", "009778", "009779", "009780", "009781", "009782", "009783", "009784", "009785", "009786", "009787", "009788", "009789", "009790", "009791", "009792", "009793", "009794", "009795", "009796", "009797", "009798", "009799", "009800", "009801", "009802", "009803", "009804", "009805", "009806", "009807", "009808", "009811", "009812", "009813", "009814", "009815", "009816", "009817", "009818", "009819", "009820", "009821", "009822", "009823", "009824", "009825", "009826", "009827", "009828", "009829", "009830", "009831", "009832", "009833", "009834", "009835", "009836", "009837", "009838", "009839", "009840", "009841", "009842", "009843", "009844", "009845", "009846", "009847", "009848", "009849", "009850", "009851", "009852", "009853", "009854", "009855", "009856", "009857", "009858", "009859", "009860", "009861", "009862", "009863", "009864", "009865", "009866", "009867", "009868", "009869", "009870", "009871", "009872", "009873", "009874", "009875", "009876", "009877", "009878", "009879", "009880", "009881", "009882", "009883", "009884", "009885", "009886", "009887", "009888", "009889", "009890", "009891", "009892", "009893", "009894", "009895", "009896", "009897", "009898", "009899", "009900", "009901", "009902", "009903", "009904", "009905", "009906", "009907", "009908", "011865", "011866", "011867", "011868", "011869", "011870", "011871", "011872", "011873", "011874", "011875", "011876", "011877", "011878", "011879", "011880", "011881", "011882", "011883", "011884", "011885", "011886", "011887", "011888", "011889", "011890", "011891", "011892", "011893", "011894", "011895", "011896", "011897", "011898", "011899", "011900", "011901", "011902", "011903", "011904", "011905", "011906", "011907", "011908", "011909", "011910", "011911", "011912", "011913", "011914", "011915", "011916", "011917", "011918", "011919", "011920", "011921", "011922", "011923", "011924", "011925", "011926", "011927", "011928", "011929", "011930", "011931", "011932", "011933", "011934", "011935", "011936", "011937", "011938", "011939", "011940", "011941", "011942", "011943", "011944", "011945", "011946", "011947", "011948", "011949", "011950", "011951", "011952", "011953", "011954", "011955", "011956", "011957", "011958", "011959", "011960", "011961", "011962", "011963", "011964", "011965", "011966", "011967", "011968", "011969", "011970", "011971", "011972", "011973", "011974", "011975", "011976", "011977", "011978", "011979", "011980", "011981", "011982", "011983", "011984", "011985", "011986", "011987", "011988", "011989", "011990", "011991", "011992", "011993", "011994", "011995", "011996", "011997", "011998", "011999", "012000", "012001", "012002", "012003", "012004", "012005", "012006", "012007", "012008", "012009", "012010", "012011", "012012", "012013", "012014", "012015", "012016", "012017", "012018", "012019", "012020", "012021", "012022", "012023", "012024", "012025", "012026", "012027", "012028", "012029", "012030", "012031", "012032", "012033", "012034", "012035", "012036", "012037", "012038", "012039", "012040", "012041", "012042", "012043", "012044", "012045", "012046", "012047", "012048", "012049", "012050", "012051", "012052", "012053", "012054", "012055", "012056", "012057", "012058", "012059", "012060", "012061", "012062", "012063", "012064", "012065", "012066", "012067", "012068", "012069", "012070", "012071", "012072", "012073", "012074", "012075", "012076", "012077", "012078", "012079", "012080", "012081", "012082", "012083", "012084", "012085", "012086", "012087", "012088", "012089", "012090", "012091", "012092", "012093", "012094", "012095", "012096", "012097", "012098", "012099", "012100", "012101", "012102", "012103", "012104", "012105", "012106", "012107", "012108", "012109", "012110", "012111", "012112", "012113", "012114", "012115", "012116", "012117", "012118", "012119", "012120", "012121", "012122", "012123", "012124", "012125", "012126", "012127", "012128", "012129", "012130", "012131", "012132", "012133", "012134", "012135", "012136", "012137", "012138", "012139", "012140", "012141", "012142", "012143", "012144", "012145", "012146", "012147", "012148", "012149", "012150", "012151", "012152", "012153", "012154", "012155", "012156", "012157", "012158", "012159", "012160", "012161", "012162", "012163", "012164", "012165", "012166", "012167", "012168", "012169", "012170", "012171", "012172", "012173", "012174", "012175", "012176", "012177", "012178", "012179", "012180", "012181", "012182", "012183", "012184", "012185", "012186", "012187", "012188", "012189", "012190", "012191", "012192", "012193", "012194", "012195", "012196", "012197", "012198", "012199", "012200", "012201", "012202", "012203", "012204", "012205", "012206", "012207", "012208", "012209", "012210", "012211", "012212", "012213", "012214", "012215", "012216", "012217", "012218", "012219", "012220", "012221", "012222", "012223", "012224", "012225", "012226", "012227", "012228", "012442", "012443", "012444", "012445", "012446", "012447", "012448", "012449", "012450", "012451", "012452", "012453", "012454", "012455", "012456", "012457", "012458", "012459", "012460", "012461", "012462", "012463", "012464", "012465", "012466", "012467", "012468", "012469", "012470", "012471", "012472", "012473", "012474", "012475", "012476", "012477", "012478", "012479", "012480", "012481", "012482", "012483", "012484", "012485", "012486", "012487", "012488", "012489", "012490", "012491", "012492", "012493", "012494", "012495", "012496", "012497", "012498", "012499", "012500", "012501", "012502", "012503", "012504", "012505", "012506", "012507", "012508", "012509", "012510", "012511", "012512", "012513", "012514", "012515", "012516", "012517", "012518", "012519", "012520", "012521", "012522", "012523", "012524", "012525", "012526", "012527", "012528", "012529", "012530", "012531", "012532", "012533", "012534", "012535", "012536", "012537", "012538", "012539", "012540", "012541", "012542", "012543", "012544", "012545", "012546", "012547", "012548", "012549", "012550", "012551", "012552", "012553", "012554", "012555", "012556", "012557", "012558", "012559", "012560", "012561", "012562", "012563", "012564", "012565", "012566", "012567", "012568", "012569", "012570", "012571", "012572", "012573", "012574", "012575", "012576", "012577", "012578", "012579", "012580", "012581", "012582", "012583", "012584", "012585", "012586", "012587", "012588", "012743", "012744", "012745", "012746", "012747", "012748", "012749", "012750", "012751", "012752", "012753", "012754", "012755", "012756", "012757", "012758", "012759", "012760", "012761", "012762", "012763", "012764", "012765", "012766", "012767", "012768", "012769", "012770", "012771", "012772", "012773", "012774", "012775", "012776", "012777", "012778", "012779", "012780", "012781", "012782", "012783", "012784", "012785", "012786", "012787", "012788", "012789", "012790", "012791", "012792", "012793", "012794", "012795", "012796", "012797", "012798", "012799", "012800", "012801", "012802", "012803", "012804", "012805", "012806", "012807", "012808", "012809", "012810", "012811", "012812", "012813", "012814", "012815", "012816", "012817", "012818", "012819", "012820", "012821", "012822", "012823", "012824", "012825", "012826", "012827", "012828", "012829", "012830", "012831", "012832", "012833", "012834", "012835", "012836", "012837", "012838", "012839", "012840", "012841", "012842", "012843", "012844", "012845", "012846", "012847", "012848", "012849", "012850", "012851", "012852", "012853", "012854", "012855", "012856", "012857", "012858", "012859", "012860", "012861", "012862", "012863", "012864", "012865", "012866", "012867", "012868", "012869", "012870", "012871", "012872", "012873", "012874", "012875", "012876", "012877", "012878", "012879", "012880", "012881", "012882", "012883", "012884", "012885", "012886", "012887", "012888", "012889", "012890", "012891", "012892", "012893", "012894", "012895", "012896", "012897", "012898", "012899", "012900", "012901", "012902", "012903", "012904", "012905", "012906", "012907", "012908", "012909", "012910", "012911", "012912", "012913", "012914", "012915", "012916", "012917", "012918", "012919", "012920", "012921", "012922", "012923", "012924", "012925", "012926", "012927", "012928", "012929", "012930", "012931", "012932", "012933", "012934", "012935", "012936", "013720", "013721", "013722", "013723", "013724", "013725", "013726", "013727", "013728", "013729", "013730", "013731", "013732", "013733", "013734", "013735", "013736", "013737", "013738", "013739", "013740", "013741", "013742", "013743", "013744", "013745", "013746", "013747", "013748", "013749", "013750", "013751", "013752", "013753", "013754", "013755", "013756", "013757", "013758", "013759", "013760", "013761", "013762", "013763", "013764", "013765", "013766", "013767", "013768", "013769", "013770", "013771", "013772", "013773", "013774", "013775", "013776", "013777", "013778", "013779", "013780", "013781", "013782", "013783", "013784", "013785", "013786", "013787", "013788", "013789", "013790", "013791", "013792", "013793", "013794", "013795", "013796", "013797", "013798", "013799", "013800", "013801", "013802", "013803", "013804", "013805", "013806", "013807", "013808", "013809", "013810", "013811", "013812", "013813", "013814", "013858", "013859", "013860", "013861", "013862", "013863", "013864", "013865", "013866", "013867", "013868", "013869", "013870", "013871", "013872", "013873", "013874", "013875", "013876", "013877", "013878", "013879", "013880", "013881", "013882", "013883", "013884", "013885", "013886", "013887", "013888", "013889", "013890", "013891", "013892", "013893", "013894", "013895", "013896", "013897", "013898", "013899", "013900", "013901", "013902", "013903", "013904", "013905", "013906", "013907", "013908", "013909", "013910", "013911", "013912", "013913", "013914", "013915", "013916", "013917", "013918", "013919", "013920", "013921", "013922", "013923", "013924", "013925", "013926", "013927", "013928", "013929", "013930", "013931", "013932", "013933", "013934", "013935", "013936", "013937", "013938", "013939", "013940", "013941", "013942", "013943", "013944", "013945", "013946", "013947", "013948", "013949", "013950", "013951", "013952", "013953", "013954", "013955", "013956", "013957", "013958", "013959", "013960", "013961", "013962", "013963", "013964", "013965", "013966", "013967", "013968", "013969", "013970", "013971", "013972", "013973", "014608", "014609", "014610", "014611", "014612", "014613", "014614", "014615", "014616", "014617", "014618", "014619", "014620", "014621", "014622", "014623", "014624", "014625", "014626", "014627", "014628", "014629", "014630", "014631", "014632", "014633", "014634", "014635", "014636", "014637", "014638", "014639", "014640", "014641", "014642", "014643", "014644", "014645", "014646", "014647", "014648", "014649", "014650", "014651", "014652", "014653", "014654", "014655", "014656", "014657", "014658", "014659", "014660", "014661", "014662", "014663", "014664", "014665", "014666", "014667", "014668", "014669", "014670", "014671", "014672", "014673", "014674", "014675", "014676", "014677", "014678", "014679", "014680", "014681", "014682", "014683", "014684", "014685", "014686", "014687", "014688", "014689", "014690", "014691", "014692", "015254", "015255", "015256", "015257", "015258", "015259", "015260", "015261", "015262", "015263", "015264", "015265", "015266", "015267", "015268", "015269", "015270", "015271", "015272", "015273", "015274", "015275", "015276", "015277", "015278", "015279", "015280", "015281", "015282", "015283", "015284", "015285", "015286", "015287", "015288", "015289", "015290", "015291", "015292", "015293", "015294", "015295", "015296", "015297", "015298", "015299", "015300", "015301", "015302", "015303", "015304", "015305", "015306", "015307", "015308", "015309", "015310", "015311", "015312", "015313", "015314", "015315", "015316", "015317", "015318", "015319", "015320", "015321", "015322", "015323", "015324", "015325", "015326", "015327", "015328", "015329", "015330", "015331", "015332", "015333", "015334", "015335", "015336", "015337", "015338", "015339", "015340", "015341", "015342", "015343", "015344", "015345", "015346", "015347", "015348", "015349", "015350", "015351", "015352", "015353", "015354", "015355", "015356", "015357", "015358", "015359", "015360", "015361", "015362", "015363", "015364", "015365", "015366", "015367", "015368", "015369", "015370", "015371", "015372", "015373", "015374", "015379", "015380", "015381", "015382", "015383", "015384", "015385", "015386", "015387", "015388", "015389", "015390", "015391", "015392", "015393", "015394", "015395", "015396", "015397", "015398", "015399", "015400", "015401", "015402", "015403", "015404", "015405", "015406", "015407", "015408", "015409", "015410", "015411", "015412", "015413", "015414", "015415", "015416", "015417", "015418", "015419", "015420", "015421", "015422", "015423", "015424", "015425", "015426", "015427", "015428", "015429", "015430", "015431", "015432", "015433", "015434", "015435", "015436", "015437", "015438", "015439", "015440", "015441", "015442", "015443", "015444", "015445", "015446", "015447", "015448", "015449", "015450", "015451", "015452", "015453", "015454", "015455", "015456", "015457", "015458", "015459", "015460", "015461", "015462", "015463", "015464", "015465", "015466", "015467", "015468", "015469", "015470", "015471", "015472", "015473", "015474", "015475", "015476", "015477", "015478", "015479", "015480", "015481", "015482", "015483", "015484", "015485", "015486", "015487", "015488", "015489", "015490", "015491", "015492", "015493", "015494", "015495", "015496", "015497", "015498", "015499", "015500", "015501", "015502", "015503", "015504", "015505", "015506", "015507", "015508", "015509", "015510", "015511", "015512", "015513", "015514", "015515", "015516", "015517", "015518", "015519", "015520", "015521", "015522", "015523", "015524", "015525", "015526", "015527", "015528", "015529", "015530", "015531", "015532", "015533", "015534", "015535", "015536", "015537", "015538", "015539", "015540", "015541", "015542", "015543", "015544", "015545", "015546", "015547", "015548", "015549", "015550", "015551", "015552", "015553", "015554", "015555", "015556", "015557", "015558", "015559", "015560", "015561", "015562", "015563", "015564", "015565", "015566", "015567", "015568", "015569", "015570", "015571", "015572", "015573", "015574", "015575", "015576", "015577", "015578", "015579", "015580", "015581", "015582", "015583", "015584", "015585", "015586", "015587", "015588", "015589", "015590", "015591", "015592", "015593", "015594", "015595", "015596", "015597", "015598", "015599", "015600", "015601", "015602", "015603", "015604", "015605", "015606", "015607", "015608", "015609", "015610", "015611", "015612", "015613", "015614", "015615", "015616", "015617", "015618", "015619", "015620", "015621", "015622", "015623", "015624", "015625", "015626", "015627", "015628", "015629", "015630", "015631", "015632", "015633", "015634", "015635", "015636", "015637", "015638", "015639"], "test_A": ["002160", "002161", "002162", "002163", "002164", "002165", "002166", "002167", "002168", "002169", "002170", "002171", "002172", "002173", "002174", "002175", "002176", "002177", "002178", "002179", "002180", "002181", "002182", "002183", "002184", "002185", "002186", "002187", "002188", "002189", "002190", "002191", "002192", "002193", "002194", "002195", "002196", "002197", "002198", "002199", "002200", "002201", "002202", "002203", "002204", "002205", "002206", "002207", "002208", "002209", "002210", "002211", "002212", "002213", "002214", "002215", "002216", "002217", "002218", "002219", "002220", "002221", "002222", "002223", "002224", "002225", "002226", "002227", "002228", "002229", "002230", "002231", "002232", "002233", "002234", "002235", "002236", "002237", "002238", "002239", "002240", "002241", "002242", "002243", "002244", "002245", "002246", "002247", "002248", "002249", "002250", "002251", "002252", "002253", "002254", "002255", "002256", "002257", "002258", "002259", "002260", "002261", "002262", "002263", "002264", "002265", "002266", "002267", "002268", "002269", "002270", "002271", "002272", "002273", "002274", "002275", "002276", "002277", "002278", "002279", "002280", "002281", "002282", "002283", "002284", "002285", "002286", "002287", "002288", "002289", "002290", "002291", "002292", "002293", "002294", "002295", "002296", "002297", "002298", "002299", "002300", "002301", "002302", "002303", "002304", "002305", "002306", "002307", "002308", "002309", "002310", "002311", "002312", "002313", "002314", "002315", "002316", "002317", "002318", "002319", "002320", "002321", "002322", "002323", "002324", "002325", "002326", "002327", "002328", "002329", "002330", "002331", "002332", "002333", "002334", "002335", "002336", "002337", "002338", "002339", "002340", "002341", "002342", "002847", "002848", "002849", "002850", "002851", "002852", "002853", "002854", "002855", "002856", "002857", "002858", "002859", "002860", "002861", "002862", "002863", "002864", "002865", "002866", "002867", "002868", "002869", "002870", "002871", "002872", "002873", "002874", "002875", "002876", "002877", "002878", "002879", "002880", "002881", "002882", "002883", "002884", "002885", "002886", "002887", "002888", "002889", "002890", "002891", "002892", "002893", "002894", "002895", "002896", "002897", "002898", "002899", "002900", "002901", "002902", "002903", "002904", "002905", "002906", "002907", "002908", "002909", "002910", "002911", "002912", "002913", "002914", "002915", "002916", "002917", "002918", "002919", "002920", "002921", "002922", "002923", "002924", "002925", "002926", "002927", "002928", "002929", "002930", "002931", "002932", "002933", "002934", "002935", "002936", "002937", "002938", "002939", "002940", "002941", "002942", "002943", "002944", "002945", "002946", "002947", "002948", "002949", "002950", "002951", "002952", "002953", "002954", "002955", "002956", "002957", "002958", "002959", "002960", "002961", "002962", "002963", "002964", "002965", "002966", "002967", "002968", "002969", "002970", "002971", "002972", "002973", "002974", "002975", "002976", "002977", "002978", "002979", "002980", "002981", "002982", "002983", "002984", "002985", "002986", "002987", "002988", "002989", "002990", "002991", "002992", "002993", "002994", "002995", "002996", "002997", "002998", "002999", "003000", "003001", "003002", "003003", "003004", "003005", "003006", "003007", "003008", "003009", "003010", "003011", "003012", "003013", "003014", "003015", "003016", "003017", "003018", "005052", "005053", "005054", "005055", "005056", "005057", "005058", "005059", "005060", "005061", "005062", "005063", "005064", "005065", "005066", "005067", "005068", "005069", "005070", "005071", "005072", "005073", "005074", "005075", "005076", "005077", "005078", "005079", "005080", "005081", "005082", "005083", "005084", "005085", "005086", "005087", "005088", "005089", "005090", "005091", "005092", "005093", "005094", "005095", "005096", "005097", "005098", "005099", "005100", "005101", "005102", "005103", "005104", "005105", "005106", "005107", "005108", "005109", "005110", "005111", "005112", "005113", "005114", "005115", "005116", "005117", "005118", "005119", "005120", "005121", "005122", "005123", "005124", "005125", "005126", "005127", "005128", "005129", "005130", "005131", "005132", "005133", "005134", "005135", "005136", "005137", "005138", "005139", "005140", "005141", "005142", "005143", "005144", "005145", "005146", "005147", "005148", "005149", "005150", "005151", "005152", "005153", "005154", "005155", "005156", "005157", "005158", "005159", "005160", "005161", "005162", "005163", "005164", "005165", "005166", "005167", "005168", "005169", "005170", "005171", "005172", "005173", "005174", "005175", "005176", "005177", "005178", "005179", "005180", "005181", "005182", "005183", "005184", "005185", "005186", "005187", "005188", "005189", "005190", "005191", "005192", "005193", "005194", "005195", "005196", "005197", "005198", "005199", "005200", "005201", "005202", "005203", "005204", "005205", "005206", "005207", "005208", "005209", "005210", "005211", "005212", "005213", "005214", "005215", "005216", "005217", "005218", "005219", "005220", "005221", "005222", "005223", "005224", "005225", "005226", "005227", "005228", "005229", "005230", "005231", "005232", "005233", "007008", "007009", "007010", "007011", "007012", "007013", "007014", "007015", "007016", "007017", "007018", "007019", "007020", "007021", "007022", "007023", "007024", "007025", "007026", "007027", "007028", "007029", "007030", "007031", "007032", "007033", "007034", "007035", "007036", "007037", "007038", "007039", "007040", "007041", "007042", "007043", "007044", "007045", "007046", "007047", "007048", "007049", "007050", "007051", "007052", "007053", "007054", "007055", "007056", "007057", "007058", "007059", "007060", "007061", "007062", "007063", "007064", "007065", "007066", "007067", "007068", "007069", "007070", "007071", "007072", "007073", "007074", "007075", "007076", "007077", "007078", "007079", "007080", "007081", "007082", "007083", "007084", "007085", "007086", "007087", "007088", "007089", "007090", "007091", "007092", "007093", "007094", "007095", "007096", "007097", "007098", "007099", "007100", "007101", "007102", "007103", "007104", "007105", "007106", "007107", "007108", "007109", "007110", "007111", "007112", "007113", "007114", "007115", "007116", "007117", "007118", "007119", "007120", "007121", "007122", "007123", "007124", "007125", "007126", "007127", "007128", "007129", "007130", "007131", "007132", "007133", "007134", "007135", "007136", "007137", "007138", "007139", "007140", "007141", "007142", "007143", "007144", "007145", "007146", "007147", "007148", "007149", "007150", "007151", "007152", "007153", "007154", "007155", "007156", "007157", "007158", "007159", "007160", "007161", "007162", "007163", "007164", "007165", "007166", "007167", "007168", "007169", "007170", "007171", "007172", "007173", "007174", "007175", "007176", "007177", "007178", "007179", "007180", "007181", "007182", "007183", "007184", "007185", "007186", "007187", "007188", "007189", "007190", "007191", "007192", "007193", "007194", "007195", "007196", "007197", "008158", "008159", "008160", "008161", "008162", "008163", "008164", "008165", "008166", "008167", "008168", "008169", "008170", "008171", "008172", "008173", "008174", "008175", "008176", "008177", "008178", "008179", "008180", "008181", "008182", "008183", "008184", "008185", "008186", "008187", "008188", "008189", "008190", "008191", "008192", "008193", "008194", "008195", "008196", "008197", "008198", "008199", "008200", "008201", "008202", "008203", "008204", "008205", "008206", "008207", "008208", "008209", "008210", "008211", "008212", "008213", "008214", "008215", "008216", "008217", "008218", "008219", "008220", "008221", "008222", "008223", "008224", "008225", "008226", "008227", "008228", "008229", "008230", "008231", "008232", "008233", "008234", "008235", "008236", "008237", "008238", "008239", "008240", "008241", "008242", "008243", "008244", "008245", "008246", "008247", "008248", "008249", "008250", "008251", "008252", "008253", "008254", "008255", "008256", "008257", "008258", "008259", "008260", "008261", "008262", "008263", "008264", "008265", "008266", "008267", "008268", "008269", "008270", "008271", "008272", "008273", "008274", "008275", "008276", "008277", "008278", "008279", "008280", "008281", "008282", "008283", "008284", "008285", "008286", "008287", "008288", "008289", "008290", "008291", "008292", "008293", "008294", "008295", "008296", "008297", "012442", "012443", "012444", "012445", "012446", "012447", "012448", "012449", "012450", "012451", "012452", "012453", "012454", "012455", "012456", "012457", "012458", "012459", "012460", "012461", "012462", "012463", "012464", "012465", "012466", "012467", "012468", "012469", "012470", "012471", "012472", "012473", "012474", "012475", "012476", "012477", "012478", "012479", "012480", "012481", "012482", "012483", "012484", "012485", "012486", "012487", "012488", "012489", "012490", "012491", "012492", "012493", "012494", "012495", "012496", "012497", "012498", "012499", "012500", "012501", "012502", "012503", "012504", "012505", "012506", "012507", "012508", "012509", "012510", "012511", "012512", "012513", "012514", "012515", "012516", "012517", "012518", "012519", "012520", "012521", "012522", "012523", "012524", "012525", "012526", "012527", "012528", "012529", "012530", "012531", "012532", "012533", "012534", "012535", "012536", "012537", "012538", "012539", "012540", "012541", "012542", "012543", "012544", "012545", "012546", "012547", "012548", "012549", "012550", "012551", "012552", "012553", "012554", "012555", "012556", "012557", "012558", "012559", "012560", "012561", "012562", "012563", "012564", "012565", "012566", "012567", "012568", "012569", "012570", "012571", "012572", "012573", "012574", "012575", "012576", "012577", "012578", "012579", "012580", "012581", "012582", "012583", "012584", "012585", "012586", "012587", "012588", "013858", "013859", "013860", "013861", "013862", "013863", "013864", "013865", "013866", "013867", "013868", "013869", "013870", "013871", "013872", "013873", "013874", "013875", "013876", "013877", "013878", "013879", "013880", "013881", "013882", "013883", "013884", "013885", "013886", "013887", "013888", "013889", "013890", "013891", "013892", "013893", "013894", "013895", "013896", "013897", "013898", "013899", "013900", "013901", "013902", "013903", "013904", "013905", "013906", "013907", "013908", "013909", "013910", "013911", "013912", "013913", "013914", "013915", "013916", "013917", "013918", "013919", "013920", "013921", "013922", "013923", "013924", "013925", "013926", "013927", "013928", "013929", "013930", "013931", "013932", "013933", "013934", "013935", "013936", "013937", "013938", "013939", "013940", "013941", "013942", "013943", "013944", "013945", "013946", "013947", "013948", "013949", "013950", "013951", "013952", "013953", "013954", "013955", "013956", "013957", "013958", "013959", "013960", "013961", "013962", "013963", "013964", "013965", "013966", "013967", "013968", "013969", "013970", "013971", "013972", "013973", "015496", "015497", "015498", "015499", "015500", "015501", "015502", "015503", "015504", "015505", "015506", "015507", "015508", "015509", "015510", "015511", "015512", "015513", "015514", "015515", "015516", "015517", "015518", "015519", "015520", "015521", "015522", "015523", "015524", "015525", "015526", "015527", "015528", "015529", "015530", "015531", "015532", "015533", "015534", "015535", "015536", "015537", "015538", "015539", "015540", "015541", "015542", "015543", "015544", "015545", "015546", "015547", "015548", "015549", "015550", "015551", "015552", "015553", "015554", "015555", "015556", "015557", "015558", "015559", "015560", "015561", "015562", "015563", "015564", "015565", "015566", "015567", "015568", "015569", "015570", "015571", "015572", "015573", "015574", "015575", "015576", "015577", "015578", "015579", "015580", "015581", "015582", "015583", "015584", "015585", "015586", "015587", "015588", "015589", "015590", "015591", "015592", "015593", "015594", "015595", "015596", "015597", "015598", "015599", "015600", "015601", "015602", "015603", "015604", "015605", "015606", "015607", "015608", "015609", "015610", "015611", "015612", "015613", "015614", "015615", "015616", "015617", "015618", "015619", "015620", "015621", "015622", "015623", "015624", "015625", "015626", "015627", "015628", "015629", "015630", "015631", "015632", "015633", "015634", "015635", "015636", "015637", "015638", "015639"]}, "cooperative_split": {"train": ["000009", "000010", "000011", "000013", "000014", "000015", "000016", "000017", "000018", "000019", "000020", "000021", "000022", "000023", "000024", "000025", "000026", "000027", "000028", "000029", "000030", "000031", "000032", "000033", "000034", "000035", "000036", "000037", "000038", "000039", "000040", "000041", "000042", "000043", "000044", "000045", "000046", "000047", "000048", "000049", "000050", "000051", "000053", "000054", "000055", "000056", "000057", "000058", "000059", "000060", "000061", "000062", "000063", "000064", "000065", "000066", "000067", "000068", "000069", "000070", "000071", "000072", "000073", "000074", "000075", "000077", "000078", "000079", "000080", "000081", "000082", "000083", "000084", "000085", "000086", "000087", "000088", "000089", "000090", "000091", "000092", "000093", "000095", "000096", "000097", "000098", "000099", "000100", "000101", "000102", "000103", "000104", "000105", "000106", "000107", "000108", "000109", "000110", "000111", "000112", "000113", "000114", "000115", "000116", "000117", "000118", "000119", "000120", "000121", "000122", "000123", "000124", "000125", "000126", "000127", "000128", "000129", "000130", "000131", "000132", "000133", "000134", "000135", "000136", "000137", "000138", "000139", "000140", "000141", "000142", "000143", "000144", "000145", "000146", "000147", "000148", "000149", "000150", "000151", "000152", "000153", "000154", "000155", "000156", "000157", "000158", "000159", "000160", "000161", "000162", "000163", "000164", "000165", "000166", "000167", "000168", "000169", "000170", "000172", "000174", "000175", "000176", "000177", "000178", "000179", "000180", "000181", "000182", "000183", "000184", "000185", "000186", "000187", "000188", "000189", "000190", "000191", "000192", "000193", "000194", "000195", "000196", "000197", "000198", "000199", "000200", "000201", "000202", "000203", "000204", "000205", "000206", "000207", "000208", "000209", "000211", "000212", "000213", "000214", "000215", "000216", "000217", "000218", "000219", "000220", "000221", "000222", "000223", "000224", "000225", "000226", "000227", "000228", "000229", "000230", "000231", "000232", "000233", "000234", "000235", "000236", "000237", "000238", "000239", "000240", "000244", "000245", "000246", "000247", "000248", "000249", "000250", "000251", "000252", "000253", "000254", "000255", "000256", "000257", "000258", "000259", "000260", "000261", "000262", "000263", "000264", "000265", "000266", "000267", "000268", "000269", "000270", "000271", "000272", "000273", "000274", "000275", "000276", "000277", "000278", "000279", "000280", "000282", "000283", "000284", "000285", "000286", "000287", "000288", "000289", "000290", "000291", "000292", "000293", "000294", "000295", "000296", "000299", "000300", "000301", "000302", "000304", "000305", "000306", "000307", "000308", "000309", "000310", "000311", "000312", "000313", "000314", "000315", "000316", "000317", "000318", "000319", "000320", "000321", "000322", "000323", "000324", "000325", "000326", "000327", "000328", "000329", "000330", "000331", "000332", "000333", "000334", "000336", "000337", "000338", "000339", "000340", "000341", "000342", "000343", "000344", "000346", "000348", "000349", "000350", "000351", "000352", "000354", "000355", "000356", "000357", "000358", "000359", "000360", "000361", "000362", "000363", "000364", "000365", "000366", "000368", "000369", "000370", "000372", "000373", "000375", "000377", "000378", "000379", "000380", "000381", "000382", "000383", "000384", "000385", "000386", "000387", "000388", "000390", "000391", "000392", "000393", "000394", "000395", "000396", "000397", "000398", "000399", "000400", "000401", "000402", "000403", "000404", "000405", "000406", "000407", "000408", "000409", "000410", "000411", "000412", "000413", "000414", "000415", "000416", "000417", "000418", "000419", "000420", "000421", "000422", "000423", "000424", "000425", "000426", "000427", "000428", "000429", "000430", "000431", "000432", "000433", "000434", "000435", "000436", "000437", "000438", "000439", "000441", "000442", "000443", "000444", "000445", "000446", "000447", "000448", "000449", "000452", "000453", "000454", "000456", "000457", "000458", "000459", "000460", "000461", "000462", "000463", "000464", "000465", "000466", "000467", "000468", "000470", "000471", "000472", "000473", "000474", "000475", "000476", "000477", "000478", "000479", "000480", "000481", "000483", "000484", "000485", "000486", "000487", "000488", "000489", "000490", "000491", "000492", "000493", "000494", "000495", "000496", "000497", "000498", "000499", "000500", "000501", "000502", "000503", "000504", "000505", "000506", "000507", "000508", "000509", "000510", "000511", "000512", "000513", "000514", "000515", "000516", "000517", "000518", "000519", "000520", "000521", "000522", "000523", "000524", "000525", "000526", "000527", "000528", "000529", "000530", "000531", "000532", "000533", "000534", "000535", "000536", "000537", "000538", "000539", "000540", "000541", "000542", "000543", "000544", "000546", "000547", "000548", "000549", "000550", "000551", "000552", "000553", "000554", "000555", "000556", "000557", "000558", "000559", "000560", "000561", "000562", "000563", "000564", "000565", "000566", "000567", "000568", "000569", "000570", "000571", "000572", "000573", "000574", "000575", "000576", "000577", "000578", "000579", "000580", "000581", "000582", "000583", "000584", "000585", "000586", "000587", "000588", "000589", "000590", "000591", "000592", "000593", "000594", "000595", "000596", "000597", "000598", "000599", "000600", "000601", "000602", "000603", "000604", "000605", "000606", "000607", "000608", "000609", "000610", "000611", "000612", "000613", "000614", "000615", "000616", "000617", "000618", "000619", "000620", "000621", "000622", "000623", "000624", "000625", "000626", "000627", "000628", "000629", "000630", "000631", "000632", "000633", "000634", "000635", "000636", "000637", "000638", "000639", "000640", "000641", "000642", "000643", "000644", "000645", "000646", "000647", "000648", "000649", "000650", "000651", "000652", "000653", "000654", "000655", "000656", "000657", "000658", "000659", "000660", "000661", "000662", "000663", "000664", "000665", "000666", "000667", "000668", "000669", "000670", "000671", "000672", "000673", "000674", "000675", "000676", "000677", "000678", "000679", "000680", "000681", "000682", "000683", "000684", "000685", "000686", "000687", "000688", "000689", "000690", "000691", "000692", "000693", "000694", "000695", "000696", "000697", "000698", "000699", "000700", "000701", "000702", "000703", "000704", "000705", "000706", "000707", "000708", "000709", "000710", "000711", "000712", "000713", "000714", "000715", "000716", "000717", "000718", "000719", "000720", "000721", "000722", "000723", "000724", "000725", "000726", "000727", "000728", "000729", "000730", "000731", "000732", "000733", "000734", "000735", "000736", "000737", "000738", "000739", "000740", "000741", "000742", "000743", "000744", "000745", "000746", "000747", "000748", "000749", "000750", "000751", "000752", "000753", "000754", "000755", "000756", "000757", "000758", "000759", "000760", "000761", "000762", "000763", "000764", "000765", "000766", "000767", "000768", "000769", "000770", "000771", "000772", "000773", "000774", "000775", "000776", "000777", "000778", "000779", "000780", "000781", "000782", "000783", "000784", "000785", "000786", "000787", "000788", "000789", "000790", "000791", "000792", "000793", "000794", "000795", "000796", "000797", "000798", "000799", "000800", "000801", "000802", "000803", "000804", "000805", "000806", "000807", "000808", "000809", "000810", "000811", "000812", "000813", "000814", "000815", "000816", "000817", "000818", "000819", "000820", "000821", "000822", "000823", "000824", "000825", "000826", "000827", "000828", "000829", "000830", "000831", "000832", "000833", "000834", "000835", "000836", "000837", "000838", "000839", "000840", "000841", "000842", "000843", "000844", "000845", "000846", "000847", "000848", "000849", "000850", "000851", "000852", "000853", "000854", "000855", "000856", "000857", "000858", "000859", "000860", "000861", "000862", "000863", "000864", "000865", "000866", "000867", "000868", "001083", "001084", "001085", "001086", "001087", "001088", "001089", "001090", "001091", "001092", "001093", "001094", "001095", "001096", "001097", "001098", "001099", "001100", "001101", "001102", "001103", "001104", "001105", "001106", "001108", "001109", "001110", "001111", "001112", "001113", "001114", "001115", "001116", "001117", "001118", "001119", "001120", "001121", "001122", "001123", "001124", "001125", "001126", "001127", "001128", "001129", "001130", "001131", "001132", "001133", "001134", "001135", "001136", "001137", "001138", "001139", "001140", "001141", "001143", "001144", "001145", "001146", "001147", "001148", "001149", "001150", "001151", "001153", "001154", "001155", "001156", "001157", "001158", "001159", "001160", "001161", "001162", "001163", "001164", "001165", "001166", "001167", "001168", "001169", "001170", "001171", "001172", "001174", "001176", "001177", "001178", "001179", "001180", "001181", "001182", "001183", "001184", "001185", "001186", "001187", "001188", "001189", "001190", "001191", "001192", "001193", "001194", "001195", "001196", "001197", "001198", "001199", "001200", "001201", "001202", "001204", "001205", "001206", "001207", "001208", "001209", "001210", "001211", "001212", "001213", "001214", "001215", "001216", "001217", "001219", "001220", "001221", "001223", "001224", "001226", "001227", "001228", "001229", "001230", "001231", "001232", "001233", "001234", "001235", "001236", "001237", "001238", "001239", "001240", "001241", "001242", "001243", "001244", "001245", "001246", "001247", "001248", "001249", "001250", "001251", "001252", "001253", "001254", "001255", "001257", "001258", "001259", "001260", "001261", "001262", "001263", "001264", "001265", "001266", "001267", "001268", "001270", "001271", "001272", "001273", "001274", "001275", "001276", "001277", "001278", "001279", "001280", "001281", "001283", "001284", "001285", "001286", "001287", "001288", "001289", "001290", "001291", "001292", "001293", "001295", "001296", "001302", "001303", "001304", "001305", "001306", "001307", "001308", "001309", "001310", "001311", "001312", "001313", "001314", "001315", "001316", "001317", "001318", "001319", "001320", "001321", "001322", "001323", "001324", "001325", "001326", "001327", "001328", "001329", "001330", "001332", "001333", "001334", "001335", "001336", "001337", "001338", "001339", "001340", "001341", "001342", "001343", "001344", "001345", "001346", "001348", "001349", "001350", "001351", "001352", "001353", "001354", "001355", "001356", "001357", "001358", "001359", "001361", "001362", "001363", "001364", "001365", "001366", "001367", "001369", "001370", "001371", "001372", "001373", "001374", "001375", "001376", "001377", "001378", "001379", "001380", "001381", "001382", "001383", "001384", "001385", "001386", "001387", "001388", "001389", "001390", "001391", "001392", "001393", "001394", "001395", "001396", "001397", "001398", "001399", "001400", "001401", "001402", "001403", "001404", "001405", "001406", "001407", "001408", "001409", "001410", "001411", "001412", "001413", "001414", "001415", "001416", "001417", "001418", "001419", "001420", "001421", "001422", "001423", "001424", "001425", "001426", "001427", "001428", "001429", "001430", "001431", "001432", "001433", "001434", "001435", "001436", "001437", "001438", "001439", "001440", "001441", "001443", "001444", "001445", "001446", "001447", "001448", "001449", "001450", "001451", "001452", "001453", "001454", "001455", "001456", "001457", "001458", "001459", "001460", "001461", "001462", "001463", "001464", "001465", "001466", "001467", "001468", "001469", "001470", "001471", "001472", "001473", "001474", "001475", "001476", "001482", "001483", "001484", "001485", "001486", "001487", "001488", "001489", "001490", "001491", "001492", "001493", "001494", "001495", "001496", "001497", "001498", "001499", "001500", "001501", "001502", "001503", "001504", "001505", "001506", "001507", "001508", "001509", "001510", "001511", "001512", "001513", "001514", "001515", "001865", "001866", "001867", "001869", "001870", "001871", "001872", "001873", "001874", "001875", "001876", "001877", "001878", "001879", "001880", "001881", "001882", "001883", "001884", "001885", "001886", "001887", "001888", "001889", "001890", "001891", "001892", "001893", "001894", "001895", "001896", "001897", "001899", "001900", "001901", "001902", "001903", "001904", "001905", "001906", "001907", "001908", "001909", "001910", "001911", "001912", "001913", "001914", "001915", "001916", "001917", "001918", "001919", "001920", "001921", "001922", "001923", "001924", "001925", "001926", "001927", "001928", "001930", "001931", "001932", "001933", "001934", "001935", "001936", "001937", "001938", "001939", "001940", "001941", "001942", "001943", "001944", "001946", "001947", "001948", "001949", "001950", "001951", "001952", "001953", "001954", "001955", "001956", "001957", "001958", "001959", "001960", "001961", "001962", "001963", "001964", "001965", "001966", "001967", "001968", "001969", "001970", "001971", "001972", "001973", "001974", "001975", "001976", "001977", "001978", "001979", "001980", "001981", "001982", "001983", "001984", "001985", "001986", "001987", "001988", "001989", "001990", "001991", "001992", "001993", "001994", "001995", "001996", "001997", "001998", "001999", "002000", "002001", "002002", "002003", "002004", "002005", "002006", "002007", "002008", "002009", "002010", "002011", "002012", "002013", "002014", "002015", "002016", "002017", "002018", "002019", "002020", "002021", "002022", "002023", "002024", "002025", "002026", "002027", "002028", "002029", "002030", "002031", "002032", "002033", "002034", "002035", "002036", "002037", "002038", "002039", "002040", "002041", "002042", "002043", "002044", "002045", "002046", "002047", "002048", "002049", "002050", "002051", "002052", "002053", "002054", "002055", "002056", "002057", "002058", "002059", "002060", "002061", "002062", "002063", "002064", "002244", "002245", "002246", "002247", "002248", "002249", "002250", "002251", "002252", "002253", "002254", "002255", "002256", "002257", "002258", "002259", "002260", "002261", "002262", "002263", "002264", "002265", "002266", "002267", "002268", "002269", "002270", "002271", "002272", "002273", "002289", "002290", "002291", "002292", "002293", "002294", "002295", "002296", "002297", "002298", "002299", "002300", "002301", "002302", "002303", "002304", "002305", "002306", "002307", "002308", "002309", "002310", "002311", "002312", "002313", "002314", "002315", "002316", "002317", "002318", "002319", "002320", "002321", "002322", "002323", "002324", "002325", "002326", "002327", "002328", "002329", "002330", "002331", "002332", "002333", "002334", "002335", "002336", "002337", "002338", "002339", "002340", "002341", "002342", "002343", "002344", "002345", "002346", "002347", "002348", "002349", "002350", "002351", "002352", "002353", "002354", "002355", "002356", "002357", "002358", "002359", "002360", "002361", "002362", "002363", "002364", "002365", "002366", "002367", "002368", "002369", "002370", "002371", "002372", "002373", "002374", "002375", "002376", "002377", "002378", "002379", "002380", "002381", "002382", "003211", "003212", "003213", "003214", "003215", "003216", "003217", "003218", "003219", "003220", "003221", "003222", "003223", "003224", "003225", "003226", "003227", "003228", "003229", "003230", "003231", "003232", "003233", "003234", "003235", "003236", "003237", "003238", "003239", "003240", "003241", "003242", "003243", "003244", "003245", "003246", "003247", "003248", "003249", "003250", "003251", "003252", "003253", "003254", "003255", "003256", "003257", "003258", "003259", "003260", "003261", "003279", "003280", "003281", "003282", "003283", "003284", "003285", "003286", "003287", "003288", "003289", "003290", "003291", "003292", "003293", "003294", "003295", "003296", "003297", "003298", "003299", "003300", "003301", "003302", "003303", "003304", "003305", "003306", "003307", "003308", "003309", "003310", "003311", "003312", "003313", "003314", "003315", "003316", "003317", "003318", "003319", "003320", "003321", "003322", "003323", "003324", "003325", "003326", "003327", "003328", "003329", "003330", "003331", "003332", "003333", "003334", "003335", "003336", "003337", "003338", "003339", "003340", "003341", "003342", "003343", "003344", "003345", "003346", "003347", "003348", "003349", "003350", "003351", "003352", "003353", "003354", "003355", "003356", "003357", "003358", "003359", "003360", "003361", "003362", "003363", "003364", "003365", "003366", "003367", "003368", "003369", "003370", "003492", "003493", "003494", "003495", "003496", "003497", "003498", "003499", "003500", "003501", "003502", "003503", "003504", "003505", "003506", "003507", "003508", "003509", "003510", "003511", "003512", "003513", "003514", "003515", "003516", "003517", "003518", "003519", "003520", "003521", "003522", "003523", "003524", "003525", "003526", "003527", "003528", "003529", "003530", "003531", "003532", "003533", "003534", "003535", "003536", "003537", "003538", "003539", "003540", "003541", "003542", "003543", "003544", "003545", "003546", "003547", "003548", "003549", "003550", "003551", "003552", "003553", "003554", "003555", "003556", "003557", "003558", "003559", "003560", "003561", "003562", "003563", "003564", "003565", "003566", "003567", "003568", "003569", "003570", "003571", "003572", "003573", "003574", "003575", "003576", "003577", "003578", "003579", "003580", "003581", "003582", "003583", "003584", "003585", "003586", "003587", "003588", "003589", "003590", "003591", "003592", "003593", "003594", "003595", "003596", "003597", "003598", "003599", "003600", "003601", "003602", "003603", "003604", "003605", "003606", "003607", "003608", "003609", "003610", "003611", "003612", "003613", "003614", "003615", "003616", "003617", "003618", "003619", "003620", "003621", "003622", "003623", "003624", "003625", "003626", "003627", "003628", "003629", "003630", "003631", "003632", "003633", "003634", "003635", "003636", "003637", "003638", "003639", "003640", "004262", "004263", "004264", "004265", "004266", "004267", "004268", "004269", "004270", "004271", "004272", "004273", "004274", "004275", "004276", "004277", "004278", "004279", "004280", "004281", "004282", "004283", "004284", "004285", "004286", "004287", "004288", "004289", "004290", "004291", "004292", "004293", "004294", "004295", "004296", "004297", "004298", "004299", "004300", "004301", "004302", "004303", "004304", "004305", "004306", "004307", "004308", "004309", "004310", "004311", "004312", "004313", "004314", "004315", "004316", "004317", "004318", "004319", "004320", "004321", "004322", "004323", "004324", "004325", "004326", "004327", "004328", "004329", "004330", "004331", "004332", "004333", "004334", "004335", "004336", "004337", "004338", "004339", "004340", "004341", "004342", "004343", "004344", "004345", "004346", "004347", "004348", "004349", "004350", "004351", "004352", "004353", "004354", "004355", "004356", "004357", "004358", "004359", "004360", "004361", "004362", "004363", "004364", "004365", "004366", "004367", "004368", "004369", "004370", "004371", "004372", "004373", "004374", "004375", "004376", "004377", "004378", "004379", "004380", "004381", "004382", "004383", "004386", "004388", "004389", "004394", "004395", "004396", "004397", "004398", "004399", "004400", "004401", "004402", "004403", "004404", "004405", "004406", "004407", "004408", "004409", "004410", "004411", "004412", "004413", "004414", "004415", "004416", "004417", "004418", "004419", "004420", "004421", "004422", "004423", "004424", "004425", "004426", "004427", "004428", "004429", "004430", "004431", "004432", "004433", "004434", "004435", "004436", "004437", "004438", "004439", "004440", "004441", "004442", "004443", "004444", "004445", "004446", "004447", "004448", "004449", "004450", "004451", "004452", "004453", "004454", "004455", "004456", "004457", "004458", "004459", "004460", "004461", "004462", "004463", "004464", "004465", "004466", "004467", "004468", "004469", "004470", "004471", "004472", "004473", "004474", "004475", "004476", "004477", "004478", "004479", "004480", "004481", "004482", "004483", "004484", "004485", "004486", "004487", "004488", "004489", "004490", "004491", "004492", "004493", "004494", "004495", "004496", "004497", "004498", "004499", "004500", "004501", "004502", "004503", "004504", "004505", "004506", "004507", "004508", "004509", "004510", "004511", "004512", "004513", "004514", "004515", "004516", "004517", "004518", "004519", "004520", "004521", "004522", "004523", "004524", "004525", "004526", "004527", "004528", "004529", "004530", "004531", "004532", "004533", "004534", "004535", "004536", "004537", "004538", "004539", "004540", "004541", "004542", "004543", "004544", "004545", "004546", "004547", "004548", "004549", "004550", "004551", "004552", "004553", "004695", "004696", "004697", "004698", "004699", "004700", "004701", "004702", "004703", "004704", "004705", "004706", "004707", "004708", "004709", "004710", "004711", "004712", "004713", "004714", "004715", "004716", "004717", "004718", "004719", "004720", "004721", "004722", "004723", "004724", "004725", "004726", "004727", "004728", "004729", "004730", "004731", "004732", "004733", "004734", "004735", "004754", "004755", "004756", "004757", "004758", "004759", "004760", "004761", "004762", "004763", "004764", "004765", "004766", "004767", "004768", "004769", "004770", "004771", "004772", "004773", "004774", "004775", "004776", "004777", "004778", "004779", "004780", "004781", "004782", "004783", "004784", "004785", "004786", "004787", "004788", "004789", "004790", "004791", "004792", "004793", "004794", "004795", "004796", "004797", "004798", "004799", "004800", "004801", "004802", "004803", "004804", "004805", "004806", "004807", "004808", "004809", "004810", "004811", "004812", "004813", "004814", "004815", "004816", "004817", "004818", "004819", "004820", "004821", "004822", "004823", "004824", "004825", "004826", "004827", "004828", "004829", "004830", "004831", "004832", "004833", "004834", "004835", "004836", "004837", "004838", "004839", "004840", "004841", "004842", "004843", "004844", "004845", "004846", "004847", "004848", "004849", "004850", "004851", "004852", "004853", "004854", "004855", "004856", "004857", "004858", "004859", "004860", "004861", "004862", "004863", "004864", "004865", "004866", "004867", "004868", "004869", "004870", "004871", "004872", "004873", "004874", "004875", "004876", "004877", "004878", "004879", "004880", "004881", "004882", "004883", "004884", "005415", "005416", "005417", "005418", "005419", "005420", "005421", "005422", "005423", "005424", "005425", "005426", "005427", "005428", "005429", "005430", "005431", "005432", "005433", "005434", "005435", "005436", "005437", "005438", "005439", "005440", "005441", "005442", "005443", "005444", "005445", "005446", "005447", "005448", "005449", "005450", "005451", "005452", "005453", "005454", "005455", "005456", "005457", "005458", "005459", "005460", "005461", "005462", "005463", "005464", "005465", "005466", "005467", "005468", "005469", "005470", "005471", "005472", "005473", "005474", "005475", "005476", "005477", "005478", "005479", "005480", "005481", "005482", "005483", "005484", "005485", "005486", "005487", "005488", "005489", "005490", "005491", "005492", "005493", "005494", "005495", "005496", "005497", "005498", "005499", "005500", "005501", "005502", "005503", "005504", "005505", "005506", "005507", "005508", "005509", "005510", "005511", "005512", "005513", "005514", "005515", "005516", "005517", "005518", "005519", "005520", "005521", "005522", "005523", "005524", "005525", "005526", "005527", "005528", "005529", "005530", "005531", "005532", "005533", "005534", "005535", "005536", "005537", "005538", "005539", "005540", "005541", "005542", "005543", "005544", "005545", "005546", "005547", "005548", "005549", "005550", "005551", "005552", "005553", "005554", "005555", "005556", "005557", "005558", "005559", "005560", "005561", "005562", "005563", "005564", "005565", "005566", "005567", "005568", "005569", "005570", "005571", "005572", "005573", "005574", "005576", "005577", "005578", "005579", "005580", "005581", "005582", "005583", "005584", "005585", "005586", "005587", "005588", "005589", "005590", "005591", "005592", "005593", "005596", "005597", "005598", "005599", "005600", "005601", "005602", "005603", "005604", "005605", "005606", "005607", "005608", "005609", "005610", "005611", "005612", "005613", "005614", "005615", "005616", "005617", "005618", "005619", "005620", "005621", "005622", "005623", "005624", "005625", "005626", "005627", "005628", "005629", "005630", "005631", "005632", "005633", "005634", "005635", "005636", "005637", "005638", "005639", "005640", "005641", "005642", "005643", "005644", "005645", "005646", "005647", "005648", "005649", "005650", "005651", "005652", "005653", "005654", "005655", "005656", "005657", "005658", "005659", "005660", "005661", "005662", "005663", "005664", "005665", "005666", "005667", "005668", "005669", "005670", "005671", "005672", "005673", "005674", "005675", "005676", "005677", "005678", "005679", "005680", "005681", "005682", "005683", "005684", "005685", "005686", "005687", "005688", "005689", "005690", "005691", "005692", "005693", "005694", "005695", "005696", "005697", "005698", "005699", "005700", "005701", "005702", "005703", "005704", "005705", "005706", "005707", "005708", "005709", "005710", "005711", "005712", "005713", "005714", "005715", "005716", "005717", "005718", "005719", "005720", "005721", "005722", "005723", "005724", "005725", "005726", "005727", "005728", "005729", "005730", "005731", "005732", "005733", "005734", "005735", "005736", "005737", "005738", "005739", "005740", "005741", "005742", "005743", "005919", "005920", "005921", "005922", "005923", "005924", "005925", "005926", "005927", "005928", "005929", "005930", "005931", "005932", "005933", "005934", "005935", "005936", "005937", "005938", "005939", "005940", "005941", "005942", "005943", "005944", "005945", "005946", "005947", "005948", "005949", "005950", "005951", "005952", "005953", "005954", "005955", "005956", "005957", "005958", "005959", "005960", "005961", "005962", "005963", "005964", "005965", "005966", "005967", "005968", "005969", "005970", "005971", "005972", "005973", "005974", "005975", "005976", "005977", "005978", "005979", "005980", "005981", "005982", "005983", "005984", "005985", "005986", "005987", "005988", "005989", "005990", "005991", "005992", "005993", "005994", "005995", "005996", "005997", "005998", "005999", "006000", "006001", "006002", "006003", "006004", "006005", "006006", "006007", "006008", "006009", "006010", "006011", "006012", "006013", "006014", "006015", "006016", "006017", "006018", "006019", "006020", "006021", "006022", "006023", "006024", "006025", "006026", "006027", "006028", "006029", "006030", "006031", "006032", "006033", "006034", "006035", "006036", "006037", "006038", "006039", "006040", "006041", "006042", "006043", "006044", "006045", "006046", "006047", "006048", "006049", "006050", "006051", "006052", "006053", "006054", "006055", "006056", "006058", "006059", "006060", "006061", "006062", "006063", "006064", "006065", "006066", "006067", "006068", "006069", "006070", "006071", "006072", "006073", "006074", "006075", "006076", "006077", "006078", "006079", "006080", "006081", "006082", "006083", "006084", "006085", "006086", "006087", "006088", "006089", "006090", "006091", "006092", "006093", "006094", "006095", "006096", "006097", "006098", "006099", "006100", "006101", "006102", "006103", "006104", "006105", "006106", "006107", "006108", "006109", "006110", "006111", "006112", "006113", "006114", "006115", "006116", "006117", "006118", "006119", "006120", "006121", "006122", "006123", "006124", "006125", "006126", "006127", "006128", "006129", "006130", "006131", "006132", "006133", "006134", "006135", "006136", "006137", "006138", "006139", "006140", "006141", "006142", "006143", "006144", "006145", "006146", "006147", "006148", "006149", "006150", "006151", "006152", "006153", "006154", "006155", "006156", "006157", "006158", "006159", "006160", "006161", "006162", "006163", "006164", "006165", "006166", "006167", "006168", "006169", "006170", "006171", "006172", "006173", "006174", "006175", "006176", "006177", "006178", "006179", "006180", "006181", "006182", "006183", "006184", "006185", "006186", "006187", "006188", "006189", "006190", "006191", "006192", "006193", "006194", "006195", "006196", "006197", "006198", "006199", "006200", "006201", "006202", "006203", "006204", "006205", "006206", "006207", "006208", "006209", "006210", "006211", "006212", "006213", "006214", "006215", "006216", "006217", "006218", "006219", "006220", "006221", "006222", "006223", "006224", "006225", "006226", "006227", "006228", "006229", "006230", "006231", "006232", "006233", "006234", "006235", "006236", "006237", "006238", "006239", "006240", "006241", "006242", "006243", "006244", "006245", "006246", "006248", "006249", "006250", "006251", "006252", "006253", "006254", "006255", "006256", "006257", "006258", "006259", "006260", "006261", "006262", "006263", "006264", "006265", "006266", "006267", "006268", "006269", "006270", "006271", "006272", "006273", "006274", "006275", "006276", "006277", "006278", "006279", "006280", "006281", "006282", "006283", "006284", "006285", "006286", "006287", "006288", "006289", "006290", "006291", "006292", "006293", "006294", "006295", "006296", "006297", "006298", "006299", "006300", "006301", "006302", "006303", "006304", "006305", "006306", "006307", "006308", "006309", "006310", "006311", "006312", "006313", "006314", "006315", "006316", "006317", "006318", "006319", "006320", "006321", "006322", "006323", "006324", "006325", "006326", "006327", "006328", "006329", "006330", "006331", "006332", "006333", "006334", "006335", "006336", "006337", "006338", "006339", "006340", "006341", "006342", "006343", "006344", "006345", "006346", "006347", "006348", "006349", "006350", "006351", "006352", "006353", "006354", "006355", "006356", "006357", "006358", "006359", "006360", "006361", "006362", "006363", "006364", "006365", "006366", "006367", "006368", "006369", "006370", "006371", "006372", "006373", "006374", "006375", "006376", "006377", "006378", "006379", "006380", "006381", "006382", "006383", "006384", "006385", "006386", "006387", "006388", "006389", "006390", "006391", "006392", "006393", "006394", "006395", "006396", "006400", "006401", "006402", "006403", "006404", "006405", "006406", "006407", "006408", "006409", "006410", "006411", "006412", "006413", "006414", "006415", "006416", "006417", "006418", "006419", "006420", "006421", "006422", "006423", "006424", "006425", "006426", "006427", "006428", "006429", "006430", "006431", "006432", "006433", "006434", "006435", "006436", "006437", "006438", "006439", "006440", "006441", "006442", "006443", "006444", "006445", "006446", "006447", "006448", "006449", "006450", "006451", "006452", "006453", "006454", "006455", "006456", "006457", "006458", "006459", "006460", "006461", "006462", "006463", "006464", "006465", "006466", "006467", "006468", "006469", "006470", "006471", "006472", "006473", "006474", "006475", "006476", "006477", "006478", "006479", "006480", "006481", "006482", "006483", "006484", "006485", "006486", "006487", "006488", "006489", "006490", "006491", "006492", "006493", "006494", "006495", "006496", "006497", "006498", "006499", "006500", "006501", "006502", "006503", "006504", "006505", "006506", "006507", "006508", "006509", "006510", "006511", "006512", "006513", "006514", "006515", "006516", "006519", "006520", "006521", "006522", "006523", "006524", "006525", "006526", "006527", "006528", "006529", "006530", "006531", "006532", "006533", "006534", "006535", "006536", "006537", "006538", "006539", "006540", "006541", "006542", "006543", "006544", "006545", "006546", "006547", "006548", "006549", "006550", "006551", "006552", "006553", "006554", "006555", "006556", "006557", "006558", "006559", "006560", "006561", "006562", "006563", "006564", "006565", "006566", "006567", "006568", "006569", "006570", "006571", "006572", "006573", "006574", "006575", "006576", "006577", "006578", "006579", "006580", "006581", "006582", "006583", "006584", "006585", "006586", "006587", "006588", "006589", "006590", "006591", "006592", "006593", "006594", "006595", "006596", "006597", "006598", "006600", "006602", "006603", "006604", "006605", "006606", "006607", "006608", "006609", "006610", "006611", "006612", "006613", "006614", "006615", "006616", "006617", "006618", "006619", "006620", "006621", "006622", "006623", "006624", "006625", "006626", "006627", "006628", "006629", "006630", "006631", "006632", "006633", "006634", "006635", "006636", "006637", "006638", "006639", "006640", "006641", "006642", "006643", "006644", "006645", "006646", "006647", "006648", "006649", "006650", "006651", "006652", "006653", "006654", "006655", "006656", "006657", "006658", "006659", "006660", "006661", "006662", "006663", "006664", "006665", "006666", "006667", "006668", "006669", "006670", "006671", "006672", "006673", "006674", "006675", "006676", "006677", "006678", "006679", "006680", "006681", "006682", "006683", "006684", "006685", "006686", "006687", "006688", "006689", "006690", "006691", "006692", "006693", "006694", "006695", "006696", "006698", "006699", "006700", "006701", "006702", "006703", "006704", "006705", "006706", "006707", "006708", "006709", "006710", "006711", "006712", "006713", "006714", "006715", "006716", "006717", "006718", "006719", "006720", "006721", "006722", "006723", "006724", "006725", "006726", "006727", "006728", "006729", "006730", "006731", "006732", "006733", "006734", "006735", "006736", "006737", "006738", "006739", "006740", "006741", "006742", "006743", "006744", "006745", "006746", "006747", "006748", "006749", "006750", "006751", "006752", "006753", "006754", "006755", "006756", "006757", "006758", "006759", "006760", "006761", "006762", "006763", "006764", "006765", "006766", "006767", "006768", "006769", "006770", "006771", "006772", "006773", "006774", "006775", "006776", "006777", "006778", "006779", "006780", "006781", "006782", "006783", "006784", "006785", "006786", "006787", "006788", "006789", "006790", "006791", "006792", "006793", "006794", "006795", "006796", "006797", "006798", "006799", "006800", "006801", "006802", "006803", "006804", "006805", "006806", "006807", "006808", "006809", "006810", "006811", "006812", "006813", "006814", "006815", "006816", "007257", "007258", "007259", "007260", "007261", "007262", "007263", "007264", "007265", "007266", "007267", "007268", "007269", "007270", "007271", "007272", "007273", "007274", "007275", "007276", "007277", "007278", "007279", "007280", "007281", "007282", "007283", "007284", "007285", "007286", "007287", "007288", "007289", "007290", "007291", "007292", "007293", "007294", "007295", "007296", "007297", "007298", "007299", "007300", "007301", "007302", "007303", "007304", "007305", "007306", "007307", "007308", "007309", "007310", "007311", "007312", "007313", "007314", "007315", "007316", "007317", "007318", "007319", "007320", "007321", "007322", "007323", "007324", "007325", "007326", "007327", "007328", "007329", "007330", "007331", "007332", "007333", "007334", "007335", "007336", "007337", "007338", "007339", "007340", "007341", "007342", "007343", "007344", "007345", "007346", "007347", "007348", "007349", "007350", "007351", "007352", "007353", "007354", "007355", "007356", "007357", "007358", "007359", "007360", "007361", "007362", "007363", "007364", "007365", "007366", "007367", "007368", "007369", "007370", "007371", "007372", "007373", "007374", "007375", "007376", "007383", "007384", "007385", "007386", "007387", "007388", "007389", "007390", "007391", "007392", "007393", "007394", "007395", "007396", "007397", "007398", "007399", "007400", "007401", "007402", "007403", "007404", "007405", "007406", "007407", "007408", "007409", "007410", "007411", "007412", "007413", "007414", "007415", "007416", "007417", "007418", "007419", "007420", "007421", "007422", "007423", "007424", "007425", "007426", "007427", "007428", "007429", "007430", "007431", "007432", "007433", "007434", "007435", "007436", "007437", "007438", "007439", "007440", "007441", "007442", "007443", "007444", "007445", "007446", "007447", "007448", "007449", "007450", "007451", "007452", "007453", "007454", "007455", "007457", "007458", "007459", "007460", "007461", "007462", "007463", "007464", "007465", "007466", "007467", "007468", "007469", "007470", "007471", "007472", "007473", "007474", "007475", "007476", "007477", "007478", "007479", "007480", "007481", "007482", "007483", "007484", "007485", "007486", "007487", "007488", "007489", "007490", "007491", "007492", "007493", "007494", "007495", "007496", "007497", "007498", "007499", "007500", "007501", "007502", "007503", "007504", "007505", "007506", "007507", "007508", "007509", "007510", "007511", "007512", "007513", "007514", "007515", "007516", "007517", "007518", "007519", "007520", "007521", "007522", "007523", "007524", "007525", "007526", "007527", "007528", "007529", "007530", "007531", "007532", "007533", "007534", "007535", "007536", "007537", "007538", "007539", "007540", "007541", "007542", "007543", "007544", "007545", "007546", "007547", "007548", "007549", "007550", "007551", "007552", "007553", "007554", "007555", "007556", "007557", "007558", "007559", "007560", "007561", "007562", "007563", "007564", "007565", "007566", "007567", "007568", "007569", "007570", "007571", "007572", "007573", "007574", "007575", "007576", "007577", "007578", "007579", "007580", "007581", "007582", "007583", "007584", "007585", "007586", "007587", "007588", "007589", "007590", "007591", "007592", "007593", "007594", "007595", "007596", "007597", "007598", "007599", "007600", "007601", "007602", "007603", "007604", "007605", "007606", "007607", "007608", "007609", "007610", "007611", "007612", "007613", "007614", "007615", "007616", "007617", "007618", "007619", "007620", "007621", "007622", "007623", "007624", "007625", "008477", "008478", "008479", "008480", "008481", "008482", "008483", "008484", "008485", "008486", "008487", "008488", "008489", "008490", "008491", "008492", "008493", "008494", "008495", "008496", "008497", "008498", "008499", "008500", "008501", "008502", "008503", "008504", "008505", "008506", "008507", "008508", "008509", "008510", "008511", "008512", "008513", "008514", "008515", "008516", "008517", "008518", "008519", "008520", "008521", "008522", "008523", "008524", "008525", "008526", "008527", "008528", "008529", "008530", "008531", "008532", "008533", "008534", "008535", "008536", "008537", "008538", "008539", "008540", "008541", "008542", "008543", "008544", "008545", "008546", "008547", "008548", "008549", "008550", "008551", "008552", "008553", "008554", "008555", "008556", "008557", "008558", "008559", "008560", "008561", "008562", "008563", "008564", "008565", "008566", "008567", "008568", "008569", "008570", "008571", "008572", "008573", "008574", "008575", "008576", "008577", "008578", "008579", "008580", "008581", "008582", "008583", "008584", "008585", "008586", "008587", "008588", "008589", "008590", "008591", "008592", "008593", "008594", "008595", "008596", "008597", "008598", "008599", "008600", "008601", "008602", "008603", "008604", "008605", "008606", "008607", "008608", "008609", "008610", "008611", "008612", "008613", "008614", "008615", "008617", "008618", "008619", "008620", "008621", "008622", "008623", "008624", "008625", "008626", "008627", "008628", "008629", "008630", "008631", "008632", "008633", "008634", "008635", "008636", "008637", "008638", "008639", "008640", "008641", "008642", "008643", "008644", "008645", "008646", "008647", "008648", "008649", "008650", "008651", "008652", "008653", "008654", "008655", "008656", "008657", "008658", "008659", "008660", "008661", "008662", "008663", "008664", "008665", "008666", "008667", "008668", "008669", "008670", "008671", "008672", "008673", "008674", "008675", "008676", "008677", "008678", "008679", "008680", "008681", "008682", "008683", "008684", "008685", "008686", "008687", "008688", "008689", "008690", "008691", "008692", "008693", "008694", "008695", "008696", "008697", "008698", "008699", "008700", "008701", "008702", "008703", "008704", "008705", "008706", "008707", "008708", "008709", "008710", "008711", "008712", "008713", "008714", "008715", "008716", "008717", "008718", "008720", "008721", "008722", "008723", "008724", "008725", "008726", "008727", "008732", "008733", "008734", "008735", "008736", "008737", "008738", "008739", "008740", "008741", "008742", "008743", "008744", "008745", "008754", "008755", "008757", "008758", "008759", "008760", "008761", "008762", "008763", "008764", "008765", "008766", "008767", "008768", "008769", "008770", "008771", "008772", "008773", "008774", "008775", "008776", "008777", "008778", "008786", "008787", "008788", "008789", "008790", "008793", "008794", "008795", "008796", "008797", "008798", "008799", "008800", "008801", "008802", "008803", "008804", "008805", "008806", "008807", "008808", "008809", "008810", "008811", "008812", "008813", "008814", "008815", "008816", "008817", "008818", "008819", "008820", "008821", "008822", "008823", "008824", "008825", "008826", "008827", "008828", "008829", "008830", "008831", "008832", "008833", "008834", "008835", "008836", "008837", "008838", "008839", "008840", "008841", "008842", "008843", "008844", "008845", "008846", "008847", "008848", "008849", "008850", "008851", "008852", "008853", "008854", "008855", "008856", "008857", "008858", "008859", "008860", "008861", "008862", "008863", "008864", "008865", "008866", "008867", "008868", "008869", "008870", "008871", "008872", "008873", "008874", "008875", "008876", "008877", "008878", "008879", "008880", "008881", "008882", "008883", "008884", "008885", "008886", "008887", "008888", "008889", "008890", "008891", "008892", "008893", "008894", "008895", "008896", "008897", "008898", "008899", "008900", "008901", "008902", "008903", "008904", "008905", "008906", "008907", "008908", "008909", "008910", "008911", "008912", "008913", "008914", "008915", "008916", "008917", "008918", "008919", "008920", "008921", "008922", "008923", "008924", "008925", "008926", "008927", "008928", "008929", "008930", "008931", "008932", "008933", "008934", "008935", "008936", "008937", "008938", "008939", "008940", "008941", "008942", "008943", "008944", "008945", "008946", "008947", "008948", "008949", "008950", "008951", "008952", "008953", "008954", "008955", "008956", "008957", "008958", "008959", "008960", "008961", "008962", "008963", "008964", "008965", "008966", "008967", "008968", "008969", "008970", "008971", "008972", "008973", "008974", "008975", "008976", "008977", "008978", "008979", "008980", "008982", "008983", "008984", "008985", "008986", "008987", "008988", "008989", "008990", "008991", "008992", "008993", "008994", "008995", "008996", "008997", "008998", "008999", "009000", "009001", "009002", "009003", "009004", "009005", "009006", "009007", "009008", "009009", "009010", "009011", "009012", "009013", "009014", "009015", "009016", "009017", "009018", "009019", "009020", "009021", "009022", "009023", "009024", "009025", "009026", "009027", "009028", "009029", "009030", "009031", "009032", "009033", "009034", "009035", "009036", "009037", "009038", "009039", "009040", "009041", "009042", "009043", "009044", "009045", "009046", "009047", "009048", "009049", "009050", "009051", "009052", "009053", "009054", "009055", "009056", "009057", "009058", "009059", "009060", "009061", "009062", "009063", "009064", "009065", "009066", "009067", "009068", "009069", "009070", "009071", "009072", "009073", "009074", "009075", "009076", "009077", "009078", "009079", "009080", "009081", "009082", "009083", "009084", "009085", "009086", "009087", "009088", "009089", "009090", "009091", "009092", "009093", "009094", "009095", "009096", "009097", "009098", "009099", "009100", "009101", "009102", "009103", "009104", "009105", "009106", "009107", "009108", "009109", "009110", "009111", "009112", "009113", "009114", "009115", "009116", "009117", "009118", "009119", "009120", "009121", "009122", "009123", "009124", "009125", "009126", "009127", "009128", "009129", "009130", "009131", "009132", "009133", "009134", "009135", "009136", "009137", "009138", "009139", "009140", "009141", "009142", "009143", "009144", "009145", "009146", "009147", "009148", "009149", "009150", "009692", "009693", "009694", "009695", "009696", "009697", "009698", "009699", "009702", "009703", "009704", "009705", "009706", "009707", "009708", "009709", "009710", "009711", "009712", "009713", "009714", "009715", "009716", "009717", "009718", "009719", "009720", "009721", "009722", "009723", "009724", "009725", "009726", "009727", "009728", "009729", "009730", "009731", "009732", "009733", "009734", "009735", "009736", "009737", "009738", "009739", "009740", "009741", "009742", "009743", "009744", "009745", "009746", "009747", "009748", "009749", "009750", "009751", "009752", "009753", "009754", "009755", "009756", "009757", "009758", "009759", "009760", "009761", "009762", "009763", "009764", "009765", "009766", "009767", "009768", "009769", "009770", "009771", "009772", "009773", "009774", "009775", "009776", "009777", "009778", "009779", "009780", "009781", "009782", "009783", "009784", "009785", "009786", "009787", "009788", "009789", "009790", "009791", "009792", "009793", "009794", "009795", "009796", "009797", "009798", "009799", "009800", "009801", "009802", "009803", "009804", "009805", "009806", "009807", "009808", "009809", "009810", "009811", "009812", "009813", "009814", "009815", "009816", "009817", "009818", "009819", "009820", "009821", "009822", "009823", "009824", "009825", "009826", "009827", "009828", "009829", "009830", "009831", "009832", "009833", "009834", "009835", "009836", "009837", "009838", "009839", "009840", "009841", "009842", "009843", "009844", "009845", "009846", "009847", "009848", "009849", "009850", "009851", "009852", "009853", "009854", "009855", "009856", "009857", "009858", "009859", "009860", "009861", "009862", "009863", "009864", "009865", "009866", "009867", "009868", "009869", "009870", "009871", "009872", "009873", "009874", "009875", "009876", "009877", "009878", "009879", "009880", "009881", "009882", "009883", "009884", "009885", "009886", "009887", "009888", "009889", "009890", "009891", "009892", "009893", "009894", "009895", "009896", "009897", "009898", "009899", "009900", "009902", "009903", "009904", "009905", "009906", "009907", "009908", "009909", "009910", "009911", "009912", "009913", "009914", "009915", "009916", "009917", "009918", "009919", "009920", "009921", "009922", "009923", "009924", "009925", "009926", "009927", "009928", "009929", "009930", "009931", "009932", "009933", "009934", "009935", "009936", "009937", "009938", "009939", "009940", "009941", "009942", "009943", "009944", "009945", "009946", "009947", "009948", "009949", "009950", "009951", "009952", "009953", "009954", "009955", "009956", "009957", "009958", "009959", "009960", "009961", "009962", "009963", "009964", "009965", "009966", "009967", "009968", "009969", "009970", "009971", "009972", "009973", "009974", "009975", "009976", "009977", "009978", "009979", "009980", "009981", "009982", "009983", "009984", "009985", "009986", "009987", "009988", "009989", "009990", "009991", "009992", "009993", "009994", "009995", "009996", "009997", "009998", "009999", "010000", "010001", "010002", "010003", "010004", "010005", "010006", "010007", "010008", "010009", "010010", "010011", "010012", "010013", "010014", "010015", "010016", "010017", "010018", "010019", "010020", "010021", "010022", "010023", "010024", "010025", "010026", "010027", "010028", "010029", "010030", "010031", "010032", "010033", "010034", "010035", "010036", "010037", "010038", "010039", "010040", "010041", "010042", "010043", "010044", "010045", "010046", "010047", "010048", "010049", "010050", "010051", "010052", "010053", "010054", "010055", "010056", "010057", "010058", "010059", "010060", "010061", "010062", "010063", "010064", "010065", "010066", "010067", "010068", "010069", "010070", "010071", "010072", "010073", "010074", "010075", "010076", "010077", "010078", "010079", "010080", "010081", "010082", "010083", "010084", "010085", "010086", "010087", "010088", "010089", "010090", "010091", "010092", "010093", "010094", "010095", "010096", "010097", "010098", "010099", "010100", "010102", "010103", "010104", "010105", "010107", "010108", "010109", "010110", "010111", "010112", "010113", "010114", "010115", "010116", "010117", "010118", "010119", "010120", "010121", "010122", "010123", "010124", "010125", "010126", "010127", "010128", "010129", "010130", "010131", "010132", "010133", "010134", "010135", "010136", "010137", "010138", "010139", "010140", "010141", "010142", "010143", "010144", "010145", "010146", "010147", "010148", "010149", "010150", "010151", "010152", "010153", "010154", "010155", "010156", "010157", "010158", "010159", "010160", "010161", "010162", "010163", "010164", "010165", "010166", "010167", "010168", "010169", "010170", "010171", "010172", "010173", "010174", "010175", "010176", "010177", "010178", "010179", "010180", "010181", "010182", "010183", "010184", "010185", "010186", "010187", "010188", "010189", "010190", "010191", "010192", "010193", "010194", "010195", "010196", "010197", "010198", "010199", "010200", "010201", "010202", "010203", "010204", "010205", "010206", "010207", "010208", "010209", "010210", "010211", "010212", "010213", "010214", "010215", "010216", "010217", "010218", "010219", "010220", "010221", "010222", "010223", "010224", "010225", "010226", "010227", "010228", "010229", "010230", "010231", "010232", "010233", "010234", "010235", "010236", "010237", "010238", "010239", "010240", "010241", "010242", "010243", "010244", "010245", "010246", "010247", "010248", "010249", "010250", "010251", "010252", "010253", "010254", "010255", "010256", "010257", "010258", "010259", "010260", "010261", "010262", "010263", "010264", "010265", "010266", "010267", "010268", "010269", "010270", "010271", "010272", "010273", "010274", "010275", "010276", "010277", "010278", "010279", "010280", "010281", "010282", "010283", "010284", "010285", "010286", "010287", "010288", "010289", "010290", "010292", "010293", "010294", "010295", "010296", "010297", "010298", "010299", "010300", "010301", "010302", "010303", "010304", "010305", "010306", "010307", "010308", "010309", "010310", "010311", "010312", "010313", "010314", "010315", "010316", "010317", "010318", "010319", "010320", "010321", "010322", "010323", "010324", "010325", "010326", "010327", "010328", "010329", "010330", "010331", "010332", "010333", "010334", "010335", "010336", "010337", "010338", "010339", "010340", "010341", "010342", "010343", "010344", "010345", "010346", "010347", "010348", "010349", "010350", "010351", "010352", "010353", "010354", "010355", "010356", "010357", "010358", "010359", "010360", "010361", "010362", "010363", "010364", "010365", "010366", "010367", "010368", "010369", "010370", "010371", "010372", "010373", "010374", "010375", "010376", "010377", "010378", "010379", "010380", "010381", "010382", "010383", "010384", "010385", "010386", "010387", "010388", "010389", "010390", "010391", "010392", "010393", "010394", "010395", "010396", "010397", "010398", "010399", "010400", "010401", "010402", "010403", "010404", "010405", "010406", "010407", "010408", "010409", "010410", "010411", "010418", "010419", "010420", "010421", "010422", "010423", "010424", "010425", "010426", "010427", "010428", "010429", "010430", "010431", "010432", "010433", "010434", "010435", "010436", "010437", "010438", "010439", "010440", "010441", "010442", "010443", "010444", "010445", "010446", "010447", "010448", "010449", "010450", "010451", "010452", "010453", "010454", "010455", "010456", "010457", "010458", "010459", "010460", "010461", "010462", "010463", "010464", "010465", "010466", "010467", "010468", "010469", "010470", "010471", "010472", "010473", "010474", "010475", "010476", "010477", "010478", "010479", "010480", "010946", "010947", "010948", "010949", "010950", "010951", "010952", "010955", "010956", "010957", "010958", "010959", "010960", "010961", "010962", "010963", "010964", "010965", "010966", "010967", "010968", "010969", "010970", "010971", "010972", "010973", "010974", "010975", "010976", "010977", "010978", "010979", "010980", "010981", "010982", "010983", "010984", "010985", "010986", "010987", "010988", "010989", "010990", "010991", "010992", "010993", "010994", "010995", "010996", "010997", "010998", "010999", "011000", "011001", "011002", "011003", "011004", "011005", "011006", "011007", "011008", "011009", "011010", "011011", "011012", "011013", "011014", "011015", "011016", "011017", "011018", "011019", "011020", "011021", "011022", "011023", "011024", "011025", "011026", "011027", "011028", "011029", "011030", "011031", "011032", "011033", "011034", "011035", "011036", "011037", "011038", "011039", "011040", "011041", "011042", "011043", "011044", "011045", "011046", "011047", "011048", "011049", "011050", "011051", "011052", "011053", "011054", "011055", "011056", "011057", "011058", "011059", "011060", "011061", "011062", "011063", "011064", "011065", "011066", "011067", "011068", "011069", "011070", "011071", "011072", "011073", "011074", "011075", "011076", "011077", "011078", "011079", "011080", "011081", "011082", "011083", "011084", "011085", "011086", "011087", "011088", "011089", "011090", "011091", "011092", "011093", "011094", "011095", "011096", "011097", "011098", "011099", "011100", "011101", "011102", "011103", "011104", "011105", "011106", "011107", "011108", "011109", "011110", "011111", "011112", "011113", "011114", "011115", "011116", "011117", "011118", "011119", "011120", "011121", "011122", "011123", "011124", "011125", "011126", "011127", "011128", "011129", "011130", "011131", "011132", "011133", "011134", "011135", "011136", "011137", "011138", "011139", "011140", "011141", "011142", "011143", "011144", "011145", "011146", "011147", "011148", "011149", "011150", "011265", "011266", "011267", "011268", "011269", "011270", "011271", "011272", "011273", "011274", "011275", "011276", "011277", "011278", "011279", "011280", "011281", "011282", "011283", "011284", "011285", "011286", "011287", "011288", "011289", "011290", "011291", "011292", "011293", "011294", "011295", "011296", "011297", "011298", "011299", "011300", "011301", "011302", "011303", "011304", "011305", "011306", "011307", "011308", "011309", "011310", "011311", "011312", "011313", "011314", "011315", "011316", "011317", "011318", "011319", "011320", "011321", "011322", "011323", "011324", "011325", "011326", "011327", "011328", "011329", "011330", "011331", "011332", "011333", "011334", "011335", "011336", "011337", "011338", "011339", "011340", "011341", "011342", "011343", "011344", "011345", "011346", "011347", "011348", "011349", "011350", "011351", "011352", "011353", "011354", "011355", "011356", "011357", "011358", "011359", "011360", "011361", "011362", "011363", "011364", "011365", "011366", "011367", "011368", "011369", "011370", "011371", "011376", "011377", "011378", "011379", "011380", "011381", "011382", "011383", "011384", "011385", "011386", "011387", "011388", "011389", "011390", "011391", "011392", "011393", "011394", "011395", "011396", "011397", "011398", "011399", "011400", "011401", "011402", "011403", "011404", "011405", "011406", "011407", "011408", "011409", "011410", "011411", "011412", "011413", "011414", "011415", "011416", "011417", "011418", "011419", "011420", "011421", "011422", "011423", "011424", "011425", "011426", "011427", "011428", "011429", "011430", "011431", "011432", "011433", "011434", "011435", "011436", "011437", "011438", "011439", "011440", "011441", "011442", "011443", "011444", "011445", "011446", "011447", "011448", "011449", "011450", "012092", "012093", "012094", "012095", "012096", "012097", "012098", "012099", "012100", "012101", "012102", "012103", "012104", "012105", "012106", "012107", "012108", "012109", "012110", "012111", "012112", "012113", "012114", "012115", "012116", "012117", "012118", "012119", "012120", "012121", "012122", "012123", "012124", "012125", "012126", "012127", "012128", "012129", "012130", "012131", "012132", "012133", "012134", "012135", "012136", "012137", "012138", "012139", "012140", "012141", "012142", "012143", "012144", "012145", "012146", "012147", "012148", "012149", "012150", "012151", "012152", "012153", "012154", "012155", "012156", "012157", "012158", "012159", "012160", "012161", "012162", "012163", "012164", "012165", "012166", "012167", "012168", "012169", "012170", "012171", "012172", "012173", "012174", "012175", "012176", "012177", "012178", "012179", "012180", "012181", "012182", "012183", "012184", "012185", "012186", "012187", "012188", "012189", "012190", "012191", "012192", "012193", "012194", "012195", "012196", "012197", "012198", "012199", "012200", "012201", "012202", "012203", "012204", "012205", "012206", "012207", "012208", "012209", "012210", "012211", "012212", "012213", "012214", "012215", "012216", "012217", "012218", "012219", "012220", "012221", "012222", "012223", "012224", "012225", "012226", "012227", "012228", "012229", "012230", "012231", "012232", "012233", "012234", "012235", "012236", "012237", "012238", "012239", "012240", "012241", "012242", "012243", "012244", "012245", "012246", "012247", "012248", "012249", "012250", "012251", "012252", "012253", "012254", "012255", "012256", "012257", "012258", "012260", "012261", "012262", "012263", "012264", "012265", "012266", "012268", "012269", "012270", "012271", "012272", "012273", "012274", "012275", "012276", "012277", "012278", "012279", "012280", "012281", "012282", "012283", "012284", "012285", "012286", "012287", "012288", "012289", "012290", "012541", "012542", "012543", "012544", "012545", "012546", "012547", "012548", "012549", "012550", "012551", "012552", "012553", "012554", "012555", "012556", "012557", "012558", "012559", "012560", "012561", "012562", "012563", "012564", "012565", "012566", "012567", "012568", "012569", "012570", "012571", "012572", "012573", "012574", "012575", "012576", "012577", "012578", "012579", "012580", "012581", "012582", "012583", "012584", "012585", "012586", "012587", "012588", "012589", "012590", "012591", "012592", "012593", "012594", "012595", "012596", "012597", "012598", "012599", "012600", "012601", "012602", "012603", "012604", "012605", "012606", "012607", "012608", "012609", "012610", "012611", "012612", "012613", "012614", "012615", "012616", "012617", "012618", "012619", "012620", "012621", "012622", "012623", "012624", "012625", "012626", "012627", "012628", "012629", "012630", "012631", "012632", "012633", "012634", "012635", "012636", "012637", "012638", "012639", "012640", "012641", "012642", "012643", "012644", "012645", "012646", "012647", "012648", "012649", "012650", "012651", "012652", "012653", "012654", "012655", "012656", "012657", "012658", "012659", "012660", "012661", "012662", "012663", "012664", "012665", "012666", "012667", "012668", "012669", "012670", "012671", "012672", "012673", "012674", "012675", "012676", "012677", "012678", "012679", "012680", "012681", "012682", "012683", "012684", "012685", "012686", "012687", "012688", "012689", "012690", "012691", "012692", "013006", "013007", "013008", "013009", "013010", "013011", "013012", "013013", "013014", "013015", "013016", "013017", "013018", "013019", "013020", "013021", "013022", "013023", "013024", "013025", "013026", "013027", "013028", "013029", "013030", "013031", "013032", "013033", "013034", "013035", "013036", "013037", "013038", "013039", "013040", "013041", "013042", "013043", "013044", "013045", "013046", "013047", "013048", "013049", "013050", "013051", "013052", "013053", "013054", "013055", "013056", "013057", "013058", "013059", "013060", "013061", "013062", "013063", "013064", "013065", "013066", "013067", "013068", "013069", "013070", "013071", "013072", "013073", "013074", "013075", "013076", "013077", "013078", "013079", "013080", "013081", "013082", "013083", "013084", "013085", "013086", "013087", "013088", "013089", "013090", "013091", "013092", "013093", "013094", "013095", "013096", "013097", "013098", "013099", "013100", "013101", "013102", "013103", "013104", "013105", "013106", "013107", "013108", "013109", "013110", "013111", "013112", "013113", "013114", "013115", "013116", "013117", "013118", "013119", "013120", "013121", "013122", "013123", "013124", "013125", "013126", "013127", "013128", "013129", "013130", "013131", "013132", "013134", "013135", "013136", "013141", "013143", "013144", "013145", "013146", "013147", "013148", "013149", "013150", "013151", "013152", "013153", "013154", "013155", "013156", "013157", "013158", "013159", "013160", "013161", "013162", "013163", "013164", "013165", "013166", "013167", "013168", "013169", "013170", "013171", "013172", "013173", "013174", "013175", "013176", "013177", "013178", "013179", "013180", "013181", "013182", "013183", "013184", "013185", "013186", "013187", "013188", "013189", "013190", "013191", "013192", "013193", "013194", "013195", "013196", "013197", "013198", "013199", "013200", "013201", "013202", "013203", "013204", "013205", "013206", "013207", "013208", "013209", "013555", "013556", "013557", "013558", "013559", "013560", "013561", "013562", "013563", "013564", "013565", "013566", "013567", "013568", "013569", "013570", "013571", "013572", "013573", "013574", "013575", "013576", "013577", "013578", "013579", "013580", "013581", "013582", "013583", "013584", "013585", "013586", "013587", "013588", "013589", "013590", "013591", "013592", "013593", "013594", "013595", "013596", "013597", "013598", "013599", "013600", "013601", "013602", "013603", "013604", "013605", "013606", "013607", "013608", "013609", "013610", "013611", "013612", "013613", "013614", "013615", "013616", "013617", "013618", "013619", "013620", "013621", "013622", "013623", "013624", "013625", "013626", "013627", "013628", "013629", "013630", "013631", "013632", "013633", "013634", "013635", "013636", "013637", "013638", "013639", "013640", "013641", "013642", "013643", "013644", "013645", "013646", "013647", "013648", "013649", "013650", "013651", "013652", "013653", "013654", "013655", "013656", "013657", "013658", "013659", "013660", "013661", "013662", "013663", "013664", "013665", "013666", "013667", "013668", "013669", "013670", "013671", "013672", "013673", "013674", "013675", "013676", "013677", "013678", "013679", "013680", "013681", "013682", "013683", "013684", "013685", "013686", "013687", "013688", "013689", "013690", "013692", "013693", "013694", "013695", "013696", "013697", "013699", "014160", "014161", "014162", "014163", "014164", "014165", "014166", "014167", "014168", "014169", "014170", "014171", "014172", "014173", "014174", "014175", "014176", "014177", "014178", "014179", "014180", "014181", "014182", "014183", "014184", "014185", "014186", "014187", "014188", "014189", "014190", "014191", "014192", "014193", "014194", "014195", "014196", "014197", "014198", "014199", "014200", "014201", "014202", "014203", "014204", "014205", "014206", "014207", "014208", "014209", "014210", "014211", "014212", "014213", "014214", "014215", "014216", "014217", "014218", "014219", "014220", "014221", "014222", "014223", "014224", "014225", "014226", "014227", "014228", "014229", "014230", "014231", "014232", "014233", "014234", "014235", "014236", "014237", "014238", "014239", "014240", "014241", "014242", "014243", "014244", "014245", "014246", "014247", "014248", "014249", "014438", "014439", "014440", "014441", "014442", "014443", "014444", "014445", "014446", "014447", "014448", "014449", "014450", "014451", "014452", "014453", "014454", "014455", "014456", "014457", "014458", "014459", "014460", "014461", "014462", "014463", "014464", "014465", "014466", "014467", "014468", "014469", "014470", "014471", "014472", "014473", "014474", "014475", "014476", "014477", "014479", "014480", "014481", "014482", "014483", "014484", "014485", "014486", "014487", "014488", "014489", "014490", "014491", "014492", "014493", "014494", "014495", "014496", "014497", "014498", "014499", "014500", "014501", "014502", "014503", "014504", "014505", "014506", "014507", "014508", "014509", "014510", "014511", "014512", "014513", "014514", "014515", "014516", "014517", "014518", "014519", "014520", "014521", "014522", "014523", "014524", "014525", "014526", "014527", "014528", "014529", "014530", "014531", "014532", "014533", "014534", "014535", "014536", "014537", "014538", "014539", "014540", "014541", "014542", "014543", "014544", "014545", "014546", "014547", "014548", "014549", "014550", "014551", "014552", "014553", "014554", "014555", "014556", "014557", "014558", "014559", "014560", "014561", "014562", "014563", "014564", "014565", "014566", "014567", "014568", "014569", "014570", "014571", "014572", "014573", "014574", "014575", "014576", "014577", "014579", "014580", "014581", "014582", "014583", "014584", "014585", "014586", "014587", "014588", "014589", "014590", "014591", "014592", "014593", "014594", "014595", "014596", "014597", "014598", "014599", "014600", "014601", "014602", "014603", "014604", "014605", "014606", "014607", "014608", "014609", "014610", "014611", "014612", "014613", "014614", "014615", "014616", "014617", "014618", "014619", "014620", "014621", "014622", "014623", "014624", "014625", "014626", "014627", "014628", "014629", "014630", "014631", "014632", "014633", "014634", "014635", "014636", "014637", "014638", "014639", "014640", "014641", "014642", "014643", "014644", "014645", "014646", "014647", "014648", "014649", "014650", "014651", "014652", "014653", "014654", "014655", "014656", "014657", "014658", "014659", "014660", "014661", "014662", "014663", "014664", "014665", "014666", "014667", "014668", "014669", "014670", "014671", "014672", "014673", "014674", "014675", "014676", "014677", "014678", "014679", "014680", "014681", "014682", "014683", "014684", "014685", "014686", "014687", "014688", "014689", "014690", "014691", "014692", "014693", "014694", "014695", "014696", "014697", "014698", "014699", "014700", "014701", "014702", "014703", "014704", "014705", "014706", "014707", "014708", "014709", "014710", "014711", "014712", "014713", "014714", "014715", "014716", "014717", "014718", "014719", "014720", "014721", "014722", "014723", "014858", "014859", "014860", "014861", "014862", "014863", "014864", "014865", "014866", "014867", "014868", "014869", "014870", "014871", "014872", "014873", "014874", "014875", "014876", "014877", "014878", "014879", "014880", "014881", "014882", "014883", "014884", "014885", "014886", "014887", "014888", "014889", "014890", "014891", "014892", "014893", "014894", "014895", "014896", "014897", "014898", "014899", "014900", "014901", "014902", "014903", "014904", "014905", "014906", "014907", "014908", "014909", "014910", "014911", "014912", "014913", "014914", "014915", "014916", "014917", "014918", "014919", "014920", "014921", "014922", "014923", "014924", "014925", "014926", "014927", "014928", "014929", "014930", "014931", "014932", "014933", "014934", "014935", "014936", "014937", "014939", "014940", "014941", "014942", "014943", "014944", "014945", "014946", "014947", "014948", "014949", "014950", "014951", "014952", "014953", "014954", "014955", "014956", "014957", "014958", "014959", "014960", "014961", "014962", "014963", "014964", "014965", "014966", "014967", "014968", "014969", "014970", "014971", "014972", "014973", "014974", "014975", "014976", "014977", "014978", "014979", "014980", "014981", "014982", "014983", "014984", "014985", "014986", "014987", "014988", "014989", "014990", "014991", "014992", "014993", "014994", "014995", "014996", "014997", "014998", "014999", "015000", "015001", "015002", "015003", "015004", "015005", "015006", "015007", "015008", "015009", "015010", "015011", "015012", "015013", "015014", "015015", "015016", "015017", "015018", "015019", "015020", "015021", "015022", "015023", "015024", "015025", "015026", "015027", "015028", "015029", "015030", "015031", "015032", "015033", "015034", "015035", "015036", "015037", "015038", "015039", "015040", "015041", "015042", "015043", "015044", "015045", "015046", "015047", "015048", "015049", "015050", "015051", "015052", "015053", "015054", "015055", "015056", "015057", "015058", "015059", "015060", "015061", "015062", "015063", "015064", "015065", "015066", "015067", "015068", "015069", "015070", "015071", "015072", "015073", "015074", "015075", "015076", "015077", "015078", "015079", "015080", "015081", "015082", "015083", "015084", "015085", "015086", "015087", "015088", "015089", "015090", "015091", "015092", "015349", "015350", "015351", "015352", "015353", "015354", "015355", "015356", "015357", "015358", "015359", "015360", "015361", "015362", "015363", "015364", "015365", "015366", "015367", "015368", "015369", "015370", "015371", "015372", "015373", "015374", "015375", "015376", "015377", "015378", "015379", "015380", "015381", "015382", "015383", "015384", "015385", "015386", "015387", "015388", "015389", "015390", "015391", "015392", "015393", "015394", "015395", "015396", "015397", "015398", "015399", "015400", "015401", "015402", "015403", "015404", "015405", "015406", "015407", "015888", "015889", "015890", "015891", "015892", "015893", "015894", "015895", "015896", "015897", "015898", "015899", "015900", "015901", "015902", "015903", "015904", "015905", "015906", "015907", "016929", "016930", "016931", "016932", "016933", "016934", "016935", "016936", "016937", "016938", "016939", "016940", "016941", "016942", "016943", "016944", "016945", "016946", "016947", "016948", "016949", "016950", "016951", "016952", "016953", "016954", "016955", "016956", "016957", "016958", "016959", "016960", "016961", "016962", "016963", "016964", "016965", "016966", "016967", "016968", "016969", "016970", "016971", "016972", "016973", "016974", "016975", "016976", "016977", "016978", "016979", "016980", "016981", "016982", "016983", "016984", "016985", "016986", "016987", "016988", "016989", "016990", "016991", "016992", "016993", "016994", "016995", "016996", "016997", "016998", "016999", "017000", "017001", "017002", "017003", "017004", "017005", "017006", "017007", "017008", "017009", "017010", "017011", "017012", "017013", "017014", "017015", "017016", "017017", "017018", "017019", "017020", "017021", "017022", "017023", "017024", "017025", "017026", "017027", "017028", "017029", "017030", "017031", "017032", "017033", "017034", "017035", "017036", "017037", "017038", "017039", "017040", "017041", "017042", "017043", "017044", "017045", "017046", "017047", "017048", "017049", "017050", "017051", "017052", "017053", "017054", "017055", "017056", "017057", "017058", "017059", "017060", "017061", "017062", "017063", "017064", "017065", "017066", "017067", "017068", "017069", "017070", "017071", "017072", "017073", "017074", "017075", "017076", "017077", "017078", "017079", "017080", "017081", "017082", "017083", "017084", "017085", "017086", "017087", "017088", "017089", "017090", "017091", "017092", "017093", "017094", "017095", "017096", "017097", "017098", "017099", "017100", "017101", "017102", "017103", "017104", "017105", "017106", "017107", "017109", "017110", "017111", "017112", "017113", "017114", "017115", "017116", "017117", "017118", "017119", "017120", "017121", "017122", "017124", "017125", "017126", "017127", "017128", "017129", "017130", "017131", "017132", "017133", "017134", "017135", "017136", "017137", "017138", "017139", "017140", "017141", "017142", "017143", "017144", "017145", "017146", "017147", "017148", "017149", "017150", "017151", "017152", "017153", "017154", "017155", "017156", "017157", "017158", "017159", "017160", "017161", "017162", "017163", "017164", "017165", "017166", "017167", "017168", "017169", "017170", "017171", "017172", "017173", "017174", "017175", "017176", "017177", "017178", "017179", "017180", "017181", "017182", "017183", "017184", "017185", "017186", "017187", "017188", "017189", "017190", "017191", "017192", "017193", "017194", "017195", "017196", "017197", "017198", "017199", "017200", "017201", "017202", "017203", "017204", "017205", "017206", "017207", "017208", "017209", "017210", "017211", "017212", "017213", "017214", "017215", "017216", "017217", "017218", "017219", "017220", "017221", "017222", "017223", "017224", "017225", "017226", "017227", "017228", "017229", "017230", "017231", "017232", "017233", "017234", "017235", "017236", "017237", "017238", "017239", "017240", "017241", "017242", "017243", "017244", "017245", "017246", "017247", "017248", "017249", "017250", "017251", "017252", "017253", "017254", "017255", "017256", "017257", "017258", "017259", "017260", "017261", "017262", "017263", "017264", "017265", "017266", "017267", "017268", "017269", "017270", "017271", "017272", "017273", "017274", "017275", "017276", "017277", "017278", "017279", "017280", "017281", "017282", "017283", "017284", "017285", "017286", "017287", "017288", "017289", "017290", "017291", "017292", "017293", "017294", "017295", "017296", "017297", "017298", "017299", "017300", "017301", "017302", "017303", "017304", "017305", "017306", "017307"], "val": ["000870", "000871", "000872", "000873", "000874", "000875", "000876", "000877", "000878", "000879", "000880", "000881", "000882", "000883", "000884", "000885", "000886", "000887", "000888", "000889", "000890", "000891", "000892", "000893", "000894", "000895", "000896", "000897", "000898", "000899", "000900", "000901", "000902", "000903", "000904", "000905", "000906", "000907", "000908", "000909", "000910", "000911", "000912", "000913", "000914", "000915", "000916", "000917", "000918", "000919", "000920", "000921", "000922", "000923", "000924", "000925", "000926", "000927", "000928", "000929", "000930", "000931", "000932", "000933", "000934", "000935", "000936", "000937", "000938", "000939", "000940", "000941", "000942", "000943", "000944", "000945", "000946", "000947", "000948", "000949", "000950", "000951", "000952", "000953", "000954", "000955", "000956", "000957", "000958", "000959", "000960", "000961", "000962", "000963", "000964", "000965", "000966", "000967", "000968", "000969", "000970", "000971", "000972", "000973", "000974", "000975", "000976", "000977", "000978", "000979", "000980", "000981", "000982", "000983", "000984", "000985", "000986", "000987", "000988", "000989", "000990", "000991", "000992", "000993", "000994", "000995", "000996", "000997", "000998", "000999", "001000", "001002", "001003", "001004", "001005", "001006", "001007", "001008", "001009", "001010", "001011", "001012", "001013", "001014", "001015", "001016", "001017", "001018", "001019", "001020", "001021", "001022", "001023", "001024", "001025", "001026", "001027", "001028", "001029", "001030", "001031", "001032", "001033", "001034", "001035", "001036", "001037", "001038", "001039", "001040", "001041", "001042", "001043", "001044", "001045", "001046", "001047", "001048", "001049", "001050", "001051", "001052", "001053", "001054", "001055", "001056", "001057", "001058", "001059", "001060", "001061", "001062", "001063", "001064", "001065", "001066", "001067", "001068", "001069", "001070", "001071", "001072", "001073", "001074", "001075", "001076", "001077", "001718", "001719", "001720", "001721", "001722", "001723", "001724", "001725", "001726", "001727", "001728", "001729", "001730", "001731", "001732", "001733", "001734", "001735", "001736", "001737", "001738", "001739", "001740", "001741", "001742", "001743", "001744", "001745", "001746", "001747", "001748", "001749", "001750", "001751", "001752", "001753", "001754", "001755", "001756", "001757", "001758", "001759", "001760", "001761", "001762", "001763", "001764", "001765", "001766", "001767", "001768", "001769", "001770", "001771", "001772", "001773", "001774", "001775", "001776", "001777", "001778", "001779", "001780", "001781", "001782", "001783", "001784", "001785", "001786", "001787", "001788", "001789", "001790", "001791", "001792", "001793", "001794", "001795", "001796", "001797", "001798", "001799", "001800", "001801", "001802", "001803", "001804", "001805", "001806", "001807", "001808", "001809", "001810", "001811", "001812", "001814", "001815", "001818", "001819", "001820", "001821", "001822", "001823", "001824", "001825", "001826", "001827", "001828", "001829", "001830", "001831", "001832", "001833", "001834", "001835", "001836", "001837", "001838", "001839", "001840", "001841", "001842", "001843", "001844", "001845", "001846", "001847", "001848", "001849", "001850", "001851", "001852", "001853", "001854", "001855", "001856", "001857", "001858", "001859", "001860", "001861", "001862", "001863", "001864", "002879", "002880", "002881", "002882", "002883", "002884", "002885", "002886", "002887", "002888", "002889", "002890", "002891", "002892", "002893", "002894", "002895", "002896", "002897", "002898", "002899", "002900", "002901", "002902", "002903", "002904", "002905", "002906", "002907", "002908", "002909", "002910", "002911", "002912", "002913", "002914", "002915", "002916", "002917", "002918", "002919", "002920", "002921", "002922", "002923", "002924", "002925", "002926", "002927", "002928", "002929", "002930", "002931", "002932", "002933", "002934", "002935", "002936", "002937", "002938", "002939", "002940", "002941", "002942", "002943", "002944", "002945", "002946", "002947", "002948", "002949", "002950", "002951", "002952", "002953", "002954", "002955", "002956", "002957", "002958", "002959", "002960", "002961", "002962", "002963", "002964", "002965", "002966", "002967", "002968", "002969", "002970", "002971", "002972", "002973", "002974", "002975", "002976", "002977", "002978", "002979", "002980", "002981", "002982", "002983", "002984", "002985", "002986", "002987", "002988", "002989", "002990", "002991", "002992", "002993", "002994", "002995", "002996", "002997", "002998", "002999", "003000", "003001", "003002", "003003", "003004", "003005", "003006", "003007", "003008", "003009", "003010", "003011", "003012", "003013", "003014", "003015", "003016", "003017", "003018", "003019", "003020", "003021", "003022", "003023", "003024", "003025", "003026", "003027", "003028", "003029", "003030", "003031", "003032", "003033", "003034", "003035", "003036", "003037", "003038", "003039", "003040", "003041", "003044", "003045", "003046", "003047", "003048", "003049", "003050", "003051", "003052", "003053", "003054", "003055", "003056", "003057", "003058", "003059", "003060", "003061", "003062", "003063", "003064", "003065", "003066", "003067", "003068", "003069", "003070", "003071", "003072", "003073", "003074", "003075", "003076", "003077", "003078", "003079", "003080", "003081", "003082", "003083", "003084", "003085", "003086", "003087", "003088", "003089", "003090", "003091", "003092", "003093", "003094", "003095", "003096", "003097", "003098", "003099", "003100", "003101", "003102", "003103", "003104", "003105", "003106", "003107", "003108", "003109", "003110", "003111", "003112", "003113", "003114", "003115", "003116", "003117", "003118", "003119", "003120", "003121", "003122", "003123", "003124", "003125", "003126", "003127", "003128", "003129", "003130", "003131", "003132", "003133", "003134", "003135", "003136", "003137", "003138", "003139", "003140", "003141", "003142", "003143", "003144", "003145", "003146", "003147", "003148", "003149", "003150", "003151", "003152", "003153", "003154", "003155", "003156", "003157", "003158", "003159", "003160", "003161", "003162", "003163", "003164", "003165", "003166", "003167", "003168", "003169", "003170", "003171", "003172", "003173", "003174", "003175", "003176", "003177", "003178", "003179", "003180", "003181", "003182", "003183", "003184", "003185", "003186", "003187", "003188", "003189", "003190", "003191", "003192", "003193", "003194", "003195", "003196", "003197", "003198", "003199", "003200", "003201", "003202", "003203", "003204", "003205", "003206", "003207", "003208", "003209", "003210", "003371", "003372", "003373", "003374", "003375", "003376", "003377", "003378", "003379", "003380", "003381", "003382", "003383", "003384", "003385", "003386", "003387", "003388", "003389", "003390", "003391", "003392", "003393", "003394", "003395", "003396", "003397", "003398", "003399", "003400", "003418", "003419", "003420", "003421", "003422", "003423", "003424", "003425", "003426", "003427", "003428", "003429", "003430", "003431", "003432", "003433", "003434", "003435", "003436", "003437", "003438", "003439", "003440", "003441", "003442", "003443", "003444", "003445", "003446", "003447", "003448", "003449", "003450", "003451", "003452", "003453", "003454", "003455", "003456", "003457", "003458", "003459", "003460", "003461", "003462", "003463", "003464", "003465", "003466", "003467", "003468", "003469", "003470", "003471", "003472", "003473", "003474", "003475", "003477", "003478", "003479", "003481", "003482", "003483", "003484", "003485", "003486", "003487", "003488", "003489", "003490", "003861", "003862", "003863", "003864", "003865", "003866", "003867", "003868", "003869", "003870", "003871", "003872", "003873", "003874", "003875", "003876", "003877", "003878", "003879", "003880", "003881", "003882", "003883", "003884", "003885", "003886", "003887", "003888", "003889", "003890", "003891", "003892", "003893", "003894", "003895", "003896", "003897", "003898", "003899", "003900", "003901", "003902", "003903", "003904", "003905", "003906", "003907", "003908", "003909", "003910", "003911", "003912", "003913", "003914", "003915", "003916", "003917", "003918", "003919", "003920", "003921", "003922", "003923", "003924", "003925", "003926", "003927", "003928", "003929", "003930", "003931", "003932", "003933", "003934", "003935", "003936", "003937", "003938", "003939", "003940", "003941", "003942", "003943", "003944", "003945", "003946", "003947", "003948", "003949", "003950", "003951", "003952", "003953", "003954", "003955", "003956", "003957", "003958", "003959", "003960", "003961", "003962", "003963", "003964", "003965", "003966", "003967", "003968", "003969", "003970", "003971", "003972", "003973", "003974", "003975", "003976", "003977", "003978", "003979", "003980", "003981", "003982", "003983", "003984", "003985", "003986", "003987", "003988", "003989", "003990", "003991", "003992", "003993", "003994", "003995", "003996", "003997", "003998", "003999", "004000", "004001", "004002", "004003", "004004", "004005", "004006", "004007", "004008", "004009", "004010", "004011", "004012", "004013", "004014", "004015", "004016", "004017", "004018", "004019", "004020", "004021", "004022", "004023", "004024", "004025", "004026", "004027", "004028", "004029", "004030", "004031", "004032", "004033", "004034", "004035", "004036", "004037", "004038", "004039", "004040", "004041", "004042", "004043", "004044", "004045", "004046", "004047", "004048", "004049", "004050", "004051", "004052", "004053", "004054", "004055", "004056", "004057", "004058", "004059", "004060", "004061", "004062", "004063", "004064", "004065", "004066", "004067", "004068", "004069", "004070", "004072", "004073", "004074", "004075", "004076", "004077", "004078", "004079", "004080", "004081", "004082", "004083", "004084", "004085", "004086", "004087", "004088", "004089", "004090", "004091", "004092", "004093", "004094", "004095", "004096", "004097", "004098", "004099", "004100", "004101", "004102", "004103", "004104", "004105", "004106", "004107", "004108", "004109", "004110", "004111", "004112", "004113", "004114", "004115", "004116", "004117", "004118", "004119", "004120", "004121", "004122", "004123", "004124", "004125", "004126", "004127", "004128", "004129", "004130", "004131", "004132", "004133", "004134", "004135", "004136", "004137", "004138", "004139", "004140", "004141", "004142", "004143", "004144", "004145", "004146", "004147", "004148", "004149", "004150", "004151", "004152", "004153", "004154", "004155", "004156", "004157", "004158", "004159", "004160", "004161", "004162", "004163", "004164", "004165", "004166", "004167", "004168", "004169", "004170", "004171", "004172", "004173", "004174", "004175", "004176", "004177", "004178", "004179", "004180", "004181", "004182", "004183", "004184", "004185", "004186", "004187", "004188", "004189", "004190", "004191", "004192", "004193", "004194", "004195", "004196", "004197", "004198", "004199", "004200", "004201", "004202", "004203", "004204", "004205", "004206", "004207", "004208", "004209", "004210", "004211", "004212", "004213", "004214", "004215", "004216", "004217", "004218", "004219", "004220", "004221", "004222", "004223", "004224", "004225", "004226", "004227", "004228", "004229", "004230", "004231", "004232", "004233", "004234", "004235", "004236", "004237", "004238", "004239", "004240", "004241", "004242", "004243", "004244", "004245", "004246", "004247", "004248", "004249", "004250", "004251", "004252", "004253", "004254", "004255", "004256", "004257", "004258", "004259", "004260", "007628", "007629", "007630", "007631", "007632", "007633", "007634", "007635", "007636", "007637", "007638", "007639", "007640", "007641", "007642", "007643", "007644", "007645", "007646", "007647", "007648", "007649", "007650", "007651", "007652", "007653", "007654", "007655", "007656", "007657", "007658", "007659", "007660", "007661", "007662", "007663", "007664", "007665", "007666", "007667", "007668", "007669", "007670", "007671", "007672", "007673", "007674", "007675", "007676", "007677", "007678", "007679", "007680", "007681", "007682", "007683", "007684", "007685", "007686", "007687", "007688", "007689", "007690", "007691", "007692", "007693", "007694", "007695", "007696", "007697", "007698", "007699", "007700", "007701", "007702", "007703", "007704", "007705", "007706", "007707", "007708", "007709", "007710", "007711", "007712", "007713", "007714", "007715", "007716", "007717", "007718", "007719", "007720", "007721", "007722", "007723", "007724", "007725", "007726", "007727", "007728", "007729", "007730", "007731", "007732", "007733", "007734", "007735", "007736", "007737", "007738", "007739", "007740", "007741", "007742", "007743", "007744", "007745", "007746", "007747", "007748", "007749", "007750", "007751", "007752", "007753", "007754", "007755", "007756", "007757", "007758", "007759", "007760", "007761", "007762", "007763", "007764", "007765", "007766", "007767", "007768", "007769", "007770", "007771", "007772", "007773", "007774", "007775", "007776", "007777", "007778", "007779", "007780", "007781", "007782", "007783", "007784", "007785", "007786", "007787", "007788", "007789", "007790", "007791", "007792", "007793", "007794", "007795", "009363", "009364", "009365", "009366", "009367", "009368", "009369", "009370", "009371", "009372", "009373", "009374", "009375", "009376", "009377", "009378", "009379", "009380", "009381", "009382", "009383", "009384", "009385", "009386", "009387", "009388", "009389", "009390", "009391", "009392", "009393", "009394", "009395", "009396", "009397", "009398", "009399", "009400", "009401", "009402", "009403", "009404", "009405", "009406", "009407", "009408", "009409", "009410", "009411", "009412", "009413", "009414", "009415", "009416", "009417", "009418", "009419", "009420", "009421", "009422", "009423", "009424", "009425", "009426", "009427", "009428", "009429", "009430", "009431", "009432", "009433", "009434", "009435", "009436", "009437", "009438", "009439", "009440", "009441", "009442", "009443", "009444", "009445", "009446", "009447", "009448", "009449", "009450", "009451", "009452", "009453", "009454", "009455", "009456", "009457", "009458", "009459", "009460", "009461", "009462", "009463", "009464", "009465", "009466", "009467", "009468", "009469", "009470", "009471", "009472", "009473", "009474", "009475", "009476", "009477", "009478", "009479", "009480", "009481", "009482", "009484", "009485", "009486", "009487", "009488", "009489", "009490", "009491", "009492", "009493", "009494", "009495", "009496", "009497", "009498", "009499", "009500", "010482", "010483", "010484", "010485", "010486", "010487", "010488", "010489", "010490", "010491", "010492", "010493", "010494", "010495", "010496", "010497", "010498", "010499", "010500", "010501", "010502", "010503", "010504", "010505", "010506", "010507", "010508", "010509", "010510", "010511", "010512", "010513", "010514", "010515", "010516", "010517", "010518", "010519", "010520", "010521", "010522", "010523", "010524", "010525", "010526", "010527", "010528", "010529", "010530", "010531", "010532", "010533", "010534", "010535", "010536", "010537", "010538", "010539", "010540", "010541", "010542", "010543", "010544", "010545", "010546", "010547", "010548", "010549", "010550", "010551", "010552", "010553", "010554", "010555", "010556", "010557", "010558", "010559", "010560", "010561", "010562", "010563", "010564", "010565", "010566", "010567", "010568", "010569", "010570", "010571", "010572", "010573", "010574", "010575", "010576", "010577", "010578", "010579", "010580", "010581", "010582", "010583", "010584", "010585", "010586", "010587", "010588", "010589", "010590", "010591", "010592", "010593", "010594", "010595", "010596", "010597", "010598", "010599", "010600", "010601", "010602", "010603", "010604", "010605", "010606", "010607", "010608", "010609", "010610", "010611", "010612", "010613", "010614", "010615", "010616", "010617", "010618", "010619", "010620", "010621", "010622", "010623", "010624", "010625", "010626", "010627", "010628", "010629", "010630", "010631", "010632", "010633", "010634", "010635", "010636", "010637", "010638", "010639", "010640", "010641", "010642", "010643", "010644", "010645", "010646", "010647", "010648", "010649", "010650", "010651", "010652", "010653", "010654", "010655", "010656", "010657", "010658", "010659", "010660", "010661", "010662", "010663", "010664", "010665", "010666", "010667", "010668", "010669", "010670", "010671", "010672", "010673", "010674", "010675", "010676", "010677", "010678", "010679", "010680", "010681", "010682", "010683", "010684", "010685", "010686", "010687", "010688", "010689", "010690", "010691", "010692", "010693", "010694", "010695", "010696", "010697", "010698", "010699", "010700", "010701", "010702", "010703", "010704", "010705", "010706", "010707", "010708", "010709", "010710", "010711", "010712", "010713", "010714", "010715", "010716", "010717", "010718", "010719", "010720", "010721", "010722", "010723", "010724", "010725", "010726", "010727", "010728", "010729", "010730", "010732", "010733", "010734", "010735", "010736", "010737", "010738", "010739", "010740", "010741", "010742", "010743", "010744", "010745", "010746", "010747", "010748", "010749", "010750", "010751", "010752", "010753", "010754", "010755", "010756", "010757", "010758", "010759", "010760", "010761", "010762", "010763", "010764", "010765", "010766", "010767", "010768", "010769", "010770", "010771", "010772", "010773", "010774", "010775", "010776", "010777", "010778", "010779", "010780", "010781", "010782", "010783", "010784", "010785", "010786", "010787", "010788", "010789", "010790", "010791", "010792", "010793", "010794", "010795", "010796", "010797", "010798", "010799", "010800", "010801", "010802", "010803", "010804", "010805", "010806", "010807", "010808", "010809", "010810", "010811", "010812", "010813", "010814", "010815", "010816", "010817", "010818", "010819", "010820", "010821", "010822", "010823", "010824", "010825", "010826", "010827", "010828", "010829", "010830", "010831", "010832", "010833", "010834", "010835", "010836", "010837", "010838", "010839", "010840", "010841", "010842", "010843", "010844", "010845", "010846", "010847", "010848", "010849", "010850", "010851", "010852", "010853", "010854", "010855", "010856", "010857", "010858", "010859", "010860", "010861", "010862", "010863", "010864", "010865", "010866", "010867", "010868", "010869", "010870", "010871", "010872", "010873", "010874", "010875", "010876", "010877", "010878", "010879", "010880", "010881", "010882", "010883", "010884", "010885", "010886", "010887", "010888", "010889", "010890", "010891", "010892", "010893", "010894", "010895", "010896", "010897", "010898", "010899", "010900", "010901", "010902", "010903", "010904", "010905", "010906", "010907", "010908", "010909", "010910", "010911", "010912", "010913", "010914", "010915", "010916", "010917", "010918", "010919", "010920", "010921", "010922", "010923", "010924", "010925", "010926", "010927", "010928", "010929", "010930", "010931", "010932", "010933", "010934", "010935", "010936", "010937", "010938", "010939", "010940", "011175", "011176", "011177", "011178", "011179", "011180", "011181", "011182", "011183", "011184", "011185", "011186", "011187", "011188", "011189", "011190", "011191", "011192", "011193", "011194", "011195", "011196", "011197", "011198", "011199", "011200", "011201", "011202", "011203", "011204", "011205", "011206", "011207", "011208", "011209", "011210", "011211", "011212", "011213", "011214", "011215", "011216", "011218", "011220", "011221", "011222", "011223", "011225", "011226", "011227", "011228", "011229", "011230", "011231", "011232", "011233", "011234", "011235", "011236", "011237", "011238", "011239", "011240", "011241", "011242", "011243", "011244", "011245", "011246", "011247", "011248", "011249", "011250", "011251", "011252", "011253", "011254", "011255", "011256", "011257", "011258", "011259", "011260", "011457", "011458", "011459", "011460", "011461", "011462", "011463", "011464", "011465", "011466", "011467", "011468", "011469", "011470", "011471", "011472", "011473", "011474", "011475", "011476", "011477", "011478", "011479", "011480", "011481", "011482", "011483", "011484", "011485", "011486", "011487", "011488", "011489", "011490", "011491", "011492", "011493", "011494", "011495", "011496", "011497", "011498", "011499", "011500", "011501", "011502", "011503", "011504", "011505", "011506", "011507", "011508", "011509", "011510", "011511", "011512", "011513", "011514", "011515", "011516", "011517", "011518", "011519", "011520", "011521", "011522", "011523", "011524", "011525", "011526", "011527", "011528", "011529", "011530", "011531", "011532", "011533", "011534", "011535", "011536", "011537", "011538", "011539", "011540", "011541", "011542", "011543", "011544", "011545", "011546", "011547", "011548", "011549", "011550", "011551", "011552", "011553", "011554", "011555", "011556", "011557", "011558", "011559", "011560", "011561", "011562", "011563", "011564", "011565", "011566", "011567", "011568", "011569", "011570", "011571", "011572", "011573", "011574", "011575", "011576", "011577", "011578", "011579", "011580", "011581", "011582", "011583", "011584", "011585", "011586", "011587", "011588", "011589", "011590", "011591", "011592", "011593", "011594", "011595", "011597", "011598", "011599", "011600", "011601", "011602", "011603", "011604", "011605", "011606", "011607", "011608", "011609", "011611", "011612", "011613", "011614", "011615", "011616", "011617", "011618", "011619", "011620", "011621", "011622", "011623", "011624", "011625", "011626", "011627", "011628", "011629", "011630", "011631", "011632", "011633", "011634", "011635", "011636", "011637", "011638", "011639", "011640", "013216", "013217", "013218", "013219", "013220", "013221", "013222", "013223", "013224", "013225", "013226", "013227", "013228", "013229", "013230", "013231", "013232", "013233", "013234", "013235", "013236", "013237", "013238", "013239", "013240", "013241", "013242", "013243", "013244", "013245", "013246", "013247", "013248", "013249", "013250", "013251", "013252", "013253", "013254", "013255", "013256", "013257", "013258", "013259", "013260", "013261", "013262", "013263", "013264", "013265", "013266", "013267", "013268", "013269", "013270", "013271", "013272", "013273", "013274", "013275", "013276", "013277", "013278", "013279", "013280", "013281", "013282", "013283", "013284", "013285", "013286", "013287", "013288", "013289", "013290", "013291", "013292", "013293", "013294", "013295", "013296", "013297", "013298", "013299", "013300", "013301", "013302", "013303", "013304", "013305", "013306", "013307", "013308", "013309", "013310", "013311", "013312", "013313", "013314", "013315", "013316", "013317", "013318", "013319", "013320", "013321", "013322", "013323", "013324", "013325", "013326", "013327", "013328", "013329", "013330", "013331", "013332", "013333", "013334", "013335", "013336", "013337", "013338", "013339", "013340", "013341", "013342", "013343", "013344", "013345", "013346", "013347", "013348", "013349", "013350", "013351", "013352", "013353", "013354", "013355", "013356", "013357", "013358", "013359", "013360", "013361", "013362", "013363", "013364", "013365", "013366", "013367", "013368", "013369", "013370", "013371", "013372", "013373", "013374", "013375", "013376", "013377", "013378", "013379", "013380", "013381", "013382", "013383", "013384", "013385", "013386", "013387", "013388", "013389", "013390", "013391", "013392", "013393", "013394", "013395", "013396", "013397", "013398", "013399", "013400", "013401", "013402", "013403", "013404", "013405", "013406", "013407", "013408", "013409", "013410", "013411", "013412", "013413", "013414", "013415", "013416", "013417", "013418", "013419", "013707", "013708", "013709", "013710", "013711", "013712", "013713", "013714", "013715", "013716", "013717", "013718", "013719", "013720", "013721", "013722", "013723", "013724", "013725", "013726", "013727", "013728", "013729", "013730", "013731", "013732", "013733", "013734", "013735", "013736", "013737", "013738", "013739", "013740", "013741", "013742", "013743", "013744", "013745", "013746", "013747", "013748", "013749", "013750", "013751", "013752", "013753", "013754", "013755", "013756", "013757", "013758", "013759", "013760", "013761", "013762", "013763", "013764", "013765", "013766", "013767", "013768", "013769", "013770", "013771", "013772", "013773", "013774", "013775", "013776", "013777", "013778", "013779", "013780", "013781", "013782", "013783", "013784", "013785", "013786", "013787", "013788", "013789", "013790", "013791", "013792", "013793", "013794", "013795", "013796", "013797", "013798", "013799", "013800", "013801", "013802", "013803", "013804", "013805", "013806", "013807", "013808", "013809", "013810", "013811", "013812", "013813", "013814", "013815", "013816", "013817", "013820", "013821", "013822", "013823", "013824", "013825", "013826", "013827", "013828", "013829", "013830", "013831", "013832", "013833", "013834", "013835", "013836", "013837", "013838", "013839", "013840", "013841", "013842", "013843", "013844", "013845", "013846", "013847", "013848", "013849", "013850", "013851", "013852", "013853", "013854", "013855", "013856", "013857", "013858", "013859", "013860", "013861", "013862", "013863", "013864", "013865", "013866", "013867", "013868", "013869", "013870", "013871", "013872", "013873", "013874", "013875", "013876", "013877", "013878", "013879", "013880", "013881", "013882", "013883", "013884", "013885", "013886", "013887", "013888", "013889", "013998", "013999", "014000", "014001", "014002", "014003", "014004", "014005", "014006", "014007", "014008", "014009", "014010", "014011", "014012", "014013", "014014", "014015", "014016", "014017", "014018", "014019", "014020", "014021", "014022", "014023", "014024", "014025", "014026", "014027", "014028", "014029", "014030", "014031", "014032", "014033", "014034", "014035", "014036", "014037", "015410", "015411", "015412", "015413", "015414", "015415", "015416", "015417", "015418", "015419", "015420", "015421", "015422", "015423", "015424", "015425", "015426", "015427", "015428", "015429", "015430", "015431", "015432", "015433", "015434", "015435", "015436", "015437", "015438", "015439", "015440", "015441", "015442", "015443", "015444", "015445", "015446", "015447", "015448", "015449", "015450", "015451", "015452", "015453", "015454", "015455", "015456", "015457", "015458", "015459", "015460", "015461", "015462", "015463", "015464", "015465", "015466", "015467", "015468", "015469", "015470", "015471", "015472", "015473", "015474", "015475", "015476", "015477", "015478", "015479", "015480", "015481", "015482", "015483", "015484", "015485", "015486", "015487", "015488", "015489", "015490", "015491", "015492", "015493", "015494", "015495", "015496", "015497", "015498", "015499", "015500", "015501", "015502", "015503", "015504", "015505", "015506", "015507", "015508", "015509", "015510", "015511", "015512", "015513", "015514", "015515", "015516", "015517", "015518", "015519", "015520", "015521", "015522", "015523", "015524", "015525", "015526", "015527", "015528", "015529", "015530", "015531", "015532", "015533", "015534", "015535", "015536", "015537", "015538", "015539", "015540", "015541", "015542", "015543", "015544", "015545", "015546", "015547", "015548", "015549", "015550", "015551", "015552", "015553", "015554", "015555", "015556", "015557", "015558", "015559", "015560", "015561", "015562", "015563", "015564", "015565", "015566", "015567", "015568", "015569", "015570", "015571", "015572", "015573", "015574", "015575", "015576", "015577", "015707", "015708", "015709", "015710", "015711", "015712", "015713", "015714", "015715", "015716", "015717", "015718", "015719", "015720", "015721", "015722", "015723", "015724", "015725", "015726", "015727", "015728", "015729", "015730", "015731", "015732", "015733", "015734", "015735", "015736", "015737", "015738", "015739", "015740", "015741", "015742", "015743", "015744", "015745", "015746", "015747", "015748", "015749", "015750", "015751", "015752", "015753", "015754", "015755", "015756", "015757", "015758", "015759", "015760", "015761", "015762", "015763", "015764", "015765", "015766", "015767", "016037", "016038", "016039", "016040", "016041", "016042", "016043", "016044", "016045", "016046", "016047", "016048", "016049", "016050", "016051", "016052", "016053", "016054", "016055", "016056", "016057", "016058", "016059", "016060", "016061", "016062", "016063", "016064", "016065", "016066", "016067", "016069", "016070", "016071", "016072", "016073", "016074", "016075", "016076", "016077", "016078", "016079", "016080", "016081", "016082", "016083", "016084", "016085", "016086", "016087", "016088", "016089", "016090", "016091", "016092", "016093", "016094", "016095", "016096", "016097", "016098", "016099", "016100", "016101", "016102", "016103", "016104", "016105", "016106", "016107", "016108", "016109", "016110", "016111", "016112", "016113", "016114", "016115", "016116", "016117", "016118", "016119", "016120", "016121", "016122", "016123", "016124", "016125", "016126", "016127", "016128", "016129", "016130", "016131", "016132", "016133", "016134", "016135", "016136", "016137", "016138", "016139", "016140", "016141", "016142", "016143", "016144", "016145", "016146", "016147", "016148", "016149", "016150", "016151", "016152", "016153", "016154", "016155", "016156", "016157", "016158", "016159", "016160", "016161", "016162", "016163", "016164", "016165", "016166", "016167", "016168", "016169", "016170", "016171", "016172", "016173", "016174", "016175", "016176", "016177", "016178", "016179", "016180", "016181", "016182", "016183", "016184", "016185", "016186", "016187", "016188", "016189", "016190", "016191", "016192", "016193", "016194", "016195", "016196", "016197", "016198", "016199", "016200", "016201", "016202", "016203", "016204", "016205", "016206", "016207", "016208", "016209", "016210", "016211", "016212", "016213", "016214", "016215", "016216", "016217", "016218", "016219", "016220", "016221", "016222", "016223", "016224", "016225", "016226", "016227", "016228", "016229", "016230", "016231", "016232", "016233", "016234", "016235", "016236", "016237", "016238", "016239", "016240", "016241", "016242", "016243", "016244", "016245", "016246", "016247", "016248", "016249", "016250", "016251", "016252", "016253", "016254", "016255", "016256", "016257", "016258", "016259", "016260", "016261", "016262", "016263", "016264", "016265", "016266", "016267", "016699", "016700", "016701", "016702", "016703", "016704", "016705", "016706", "016707", "016708", "016709", "016710", "016711", "016712", "016713", "016714", "016715", "016716", "016717", "016718", "016719", "016720", "016721", "016722", "016723", "016724", "016725", "016726", "016727", "016728", "016729", "016730", "016731", "016732", "016733", "016734", "016735", "016736", "016737", "016738", "016739", "016740", "016741", "016742", "016743", "016744", "016745", "016746", "016747", "016748", "016749", "016750", "016751", "016752", "016753", "016754", "016755", "016756", "016757", "016758", "016759", "016760", "016761", "016762", "016763", "016764", "016765", "016766", "016767", "016768", "016769", "016770", "016771", "016772", "016773", "016774", "016775", "016776", "016777", "016778", "016779", "016780", "016781", "016782", "016783", "016784", "016785", "016786", "016787", "016788", "016789", "016790", "016791", "016792", "016793", "016794", "016795", "016796", "016797", "016798", "016799", "016800", "016801", "016802", "016803", "016804", "016805", "016806", "016807", "016808", "016809", "016814", "016815", "016816", "016817", "016818", "016819", "016820", "016821", "016822", "016823", "016824", "016825", "016826", "016827", "016828", "016829", "016830", "016831", "016832", "016833", "016834", "016835", "016836", "016837", "016838", "016839", "016840", "016841", "016842", "016843", "016844", "016845", "016846", "016847", "016848", "016849", "016850", "016851", "016852", "016853", "016854", "016855", "016856", "016857", "016858", "016859", "016860", "016861", "016862", "016863", "016864", "016865", "016866", "016867", "016868", "016869", "016870", "016871", "016872", "016873", "016874", "016875", "016876", "016877", "016878", "016879", "016880", "016881", "016882", "016883", "016884", "016885", "016886", "016887", "016888", "016889", "016890", "016891", "016892", "016893", "016894", "016895", "016896", "016897", "016898", "016899", "016900", "016901", "016902", "016903", "016904", "016905", "016906", "016907", "016908", "016909", "016910", "016911", "016912", "016913", "016914", "016917", "016918", "016919", "016920", "016921", "016922", "016923", "016924", "016925", "016926", "016927"], "test": ["001521", "001522", "001523", "001524", "001525", "001526", "001527", "001528", "001529", "001530", "001531", "001532", "001533", "001534", "001535", "001536", "001537", "001538", "001539", "001540", "001541", "001542", "001543", "001545", "001546", "001547", "001548", "001549", "001550", "001551", "001552", "001554", "001555", "001556", "001557", "001558", "001559", "001560", "001561", "001562", "001563", "001564", "001565", "001566", "001567", "001568", "001569", "001570", "001571", "001572", "001573", "001574", "001575", "001576", "001578", "001579", "001580", "001581", "001582", "001583", "001584", "001585", "001586", "001587", "001588", "001589", "001590", "001591", "001592", "001593", "001594", "001596", "001597", "001598", "001599", "001600", "001601", "001602", "001603", "001604", "001605", "001606", "001607", "001608", "001609", "001610", "001611", "001612", "001613", "001614", "001615", "001616", "001617", "001618", "001619", "001620", "001621", "001622", "001623", "001624", "001625", "001626", "001627", "001628", "001629", "001630", "001631", "001632", "001633", "001634", "001635", "001636", "001637", "001638", "001639", "001640", "001641", "001642", "001643", "001644", "001645", "001646", "001647", "001648", "001649", "001650", "001651", "001652", "001653", "001654", "001655", "001656", "001657", "001658", "001659", "001660", "001664", "001665", "001667", "001668", "001669", "001671", "001672", "001673", "001674", "001675", "001676", "001677", "001678", "001679", "001680", "001681", "001682", "001683", "001684", "001685", "001687", "001688", "001689", "001690", "001691", "001692", "001693", "001694", "001695", "001696", "001697", "001698", "001699", "001700", "001701", "001702", "001703", "001704", "001705", "001706", "001707", "001708", "001709", "001710", "001711", "001712", "001713", "001714", "002075", "002076", "002077", "002078", "002079", "002080", "002081", "002082", "002083", "002084", "002085", "002086", "002087", "002088", "002089", "002090", "002091", "002092", "002093", "002094", "002095", "002096", "002097", "002098", "002099", "002100", "002101", "002102", "002103", "002104", "002105", "002106", "002107", "002108", "002109", "002110", "002111", "002112", "002113", "002114", "002115", "002116", "002117", "002118", "002119", "002120", "002121", "002122", "002123", "002124", "002125", "002126", "002127", "002128", "002129", "002130", "002131", "002132", "002133", "002134", "002135", "002136", "002137", "002138", "002139", "002140", "002141", "002142", "002143", "002144", "002145", "002146", "002147", "002148", "002149", "002150", "002151", "002152", "002153", "002154", "002155", "002156", "002157", "002158", "002159", "002160", "002161", "002162", "002163", "002164", "002165", "002166", "002167", "002168", "002169", "002170", "002171", "002172", "002173", "002174", "002175", "002176", "002177", "002178", "002179", "002180", "002181", "002182", "002183", "002184", "002185", "002186", "002187", "002188", "002189", "002190", "002191", "002192", "002193", "002194", "002195", "002196", "002197", "002198", "002199", "002200", "002201", "002202", "002203", "002204", "002205", "002206", "002207", "002208", "002209", "002210", "002211", "002212", "002213", "002214", "002231", "002233", "002235", "002236", "002237", "002238", "002239", "002240", "002241", "002242", "002243", "002384", "002385", "002386", "002387", "002388", "002389", "002390", "002391", "002392", "002393", "002394", "002395", "002396", "002397", "002398", "002399", "002400", "002401", "002402", "002403", "002404", "002405", "002406", "002407", "002408", "002409", "002410", "002411", "002412", "002413", "002414", "002415", "002416", "002417", "002418", "002419", "002420", "002421", "002422", "002423", "002424", "002425", "002426", "002427", "002428", "002429", "002430", "002431", "002432", "002433", "002434", "002435", "002436", "002437", "002438", "002439", "002440", "002441", "002442", "002443", "002444", "002445", "002446", "002447", "002448", "002449", "002450", "002451", "002452", "002453", "002454", "002455", "002456", "002457", "002458", "002459", "002460", "002461", "002462", "002463", "002464", "002465", "002466", "002467", "002468", "002469", "002470", "002471", "002472", "002473", "002474", "002475", "002476", "002477", "002478", "002479", "002480", "002481", "002482", "002483", "002484", "002485", "002486", "002487", "002488", "002489", "002490", "002491", "002492", "002493", "002494", "002495", "002496", "002497", "002498", "002499", "002500", "002501", "002502", "002503", "002504", "002505", "002506", "002507", "002508", "002509", "002510", "002511", "002512", "002513", "002514", "002515", "002516", "002517", "002518", "002519", "002520", "002521", "002522", "002523", "002524", "002525", "002526", "002527", "002528", "002529", "002530", "002531", "002532", "002533", "002534", "002535", "002536", "002537", "002538", "002539", "002540", "002541", "002542", "002543", "002544", "002545", "002546", "002547", "002548", "002549", "002550", "002551", "002552", "002553", "002554", "002555", "002556", "002559", "002560", "002563", "002564", "002565", "002566", "002567", "002568", "002569", "002570", "002571", "002572", "002573", "002574", "002575", "002576", "002577", "002578", "002579", "002580", "002581", "002582", "002584", "002585", "002586", "002587", "002588", "002589", "002590", "002591", "002592", "002593", "002594", "002595", "002596", "002597", "002598", "002599", "002600", "002601", "002602", "002603", "002604", "002605", "002606", "002607", "002608", "002609", "002610", "002611", "002612", "002613", "002614", "002615", "002616", "002617", "002618", "002619", "002620", "002621", "002622", "002623", "002624", "002625", "002626", "002627", "002628", "002629", "002630", "002631", "002632", "002633", "002634", "002635", "002636", "002637", "002638", "002639", "002640", "002641", "002642", "002643", "002644", "002645", "002646", "002647", "002648", "002649", "002650", "002651", "002652", "002653", "002654", "002655", "002656", "002657", "002658", "002659", "002660", "002661", "002662", "002663", "002664", "002665", "002666", "002667", "002668", "002669", "002670", "002671", "002672", "002673", "002674", "002675", "002676", "002677", "002678", "002679", "002680", "002681", "002682", "002683", "002684", "002685", "002686", "002687", "002688", "002689", "002690", "002691", "002692", "002693", "002694", "002695", "002696", "002697", "002698", "002699", "002700", "002701", "002702", "002703", "002704", "002705", "002706", "002707", "002708", "002709", "002710", "002711", "002712", "002713", "002714", "002715", "002716", "002717", "002718", "002719", "002720", "002721", "002722", "002723", "002724", "002725", "002726", "002727", "002728", "002729", "002730", "002731", "002732", "002733", "002734", "002735", "002736", "002737", "002738", "002739", "002740", "002741", "002742", "002743", "002744", "002745", "002746", "002747", "002748", "002749", "002750", "002751", "002752", "002753", "002754", "002755", "002756", "002757", "002758", "002759", "002760", "002761", "002762", "002763", "002764", "002765", "002766", "002767", "002768", "002769", "002770", "002771", "002772", "002773", "002774", "002775", "002776", "002777", "002778", "002779", "002780", "002781", "002782", "002784", "002785", "002786", "002787", "002788", "002789", "002790", "002791", "002792", "002793", "002794", "002795", "002796", "002797", "002798", "002799", "002800", "002801", "002802", "002803", "002804", "002805", "002806", "002807", "002808", "002809", "002810", "002811", "002812", "002813", "002814", "002815", "002816", "002817", "002818", "002819", "002820", "002821", "002822", "002823", "002824", "002825", "002826", "002827", "002828", "002829", "002830", "002831", "002832", "002833", "002834", "002835", "002836", "002837", "002838", "002839", "002840", "002841", "002842", "002843", "002844", "002845", "002846", "002847", "002848", "002849", "002850", "002851", "002852", "002853", "002854", "002855", "002856", "002857", "002858", "002859", "002860", "002861", "003641", "003642", "003643", "003644", "003645", "003646", "003647", "003648", "003649", "003650", "003651", "003652", "003653", "003654", "003655", "003656", "003657", "003658", "003659", "003660", "003661", "003662", "003663", "003664", "003665", "003666", "003667", "003668", "003669", "003670", "003671", "003672", "003673", "003674", "003675", "003676", "003677", "003678", "003679", "003680", "003681", "003682", "003683", "003684", "003685", "003686", "003687", "003688", "003689", "003690", "003691", "003692", "003693", "003694", "003695", "003696", "003697", "003698", "003699", "003700", "003701", "003702", "003703", "003704", "003705", "003706", "003707", "003708", "003709", "003710", "003711", "003712", "003713", "003714", "003715", "003716", "003717", "003718", "003719", "003720", "003721", "003722", "003723", "003724", "003725", "003726", "003727", "003728", "003729", "003730", "003731", "003732", "003733", "003734", "003735", "003736", "003737", "003738", "003739", "003740", "003741", "003742", "003743", "003744", "003745", "003746", "003747", "003748", "003749", "003750", "003751", "003752", "003753", "003754", "003755", "003756", "003757", "003758", "003759", "003760", "003761", "003762", "003763", "003764", "003765", "003766", "003767", "003768", "003769", "003770", "003771", "003772", "003773", "003774", "003775", "003776", "003777", "003778", "003779", "003780", "003781", "003782", "003783", "003784", "003785", "003786", "003787", "003788", "003789", "003790", "003791", "003792", "003793", "003794", "003795", "003796", "003797", "003798", "003799", "003800", "003801", "003802", "003803", "003804", "003805", "003806", "003807", "003808", "003809", "003810", "003811", "003812", "003813", "003814", "003815", "003816", "003817", "003818", "003819", "003820", "003821", "003822", "003823", "003824", "003825", "003826", "003827", "003828", "003829", "003830", "003831", "003832", "003833", "003834", "003835", "003836", "003837", "003838", "003839", "003840", "003841", "003842", "003843", "003844", "003845", "003846", "003847", "003848", "003849", "003850", "003851", "003852", "003853", "003854", "003855", "003856", "003857", "003858", "003859", "003860", "004556", "004557", "004558", "004559", "004560", "004561", "004562", "004563", "004564", "004565", "004566", "004567", "004568", "004569", "004570", "004571", "004572", "004573", "004574", "004575", "004576", "004577", "004578", "004579", "004580", "004581", "004582", "004583", "004584", "004585", "004586", "004587", "004588", "004589", "004590", "004591", "004592", "004593", "004594", "004595", "004596", "004597", "004598", "004599", "004600", "004601", "004602", "004603", "004604", "004605", "004606", "004607", "004608", "004609", "004610", "004611", "004612", "004613", "004614", "004615", "004616", "004617", "004618", "004619", "004620", "004621", "004622", "004623", "004624", "004625", "004626", "004627", "004628", "004629", "004630", "004631", "004632", "004633", "004634", "004635", "004636", "004637", "004638", "004639", "004640", "004641", "004642", "004643", "004644", "004645", "004646", "004647", "004648", "004649", "004650", "004651", "004652", "004653", "004654", "004655", "004656", "004657", "004658", "004659", "004660", "004661", "004662", "004663", "004664", "004665", "004666", "004667", "004668", "004669", "004670", "004671", "004672", "004673", "004674", "004675", "004676", "004677", "004678", "004680", "004681", "004683", "004684", "004685", "004686", "004687", "004688", "004689", "004692", "004693", "004886", "004887", "004888", "004889", "004890", "004891", "004892", "004893", "004894", "004895", "004896", "004897", "004898", "004899", "004900", "004901", "004902", "004903", "004904", "004905", "004906", "004907", "004908", "004909", "004910", "004911", "004912", "004913", "004914", "004915", "004916", "004917", "004918", "004919", "004920", "004921", "004922", "004923", "004924", "004925", "004926", "004927", "004928", "004929", "004930", "004931", "004932", "004933", "004934", "004935", "004936", "004937", "004938", "004939", "004940", "004941", "004942", "004943", "004944", "004945", "004946", "004947", "004948", "004949", "004950", "004951", "004952", "004953", "004954", "004955", "004956", "004957", "004958", "004959", "004960", "004961", "004962", "004963", "004964", "004965", "004966", "004967", "004968", "004969", "004970", "004971", "004972", "004973", "004974", "004975", "004976", "004977", "004978", "004979", "004980", "004981", "004982", "004983", "004984", "004985", "004986", "004987", "004988", "004989", "004990", "004991", "004992", "004993", "004994", "004995", "004996", "004997", "004998", "004999", "005000", "005001", "005002", "005003", "005004", "005005", "005006", "005007", "005008", "005009", "005010", "005011", "005012", "005013", "005014", "005015", "005016", "005017", "005018", "005019", "005020", "005021", "005022", "005023", "005024", "005025", "005026", "005027", "005028", "005029", "005030", "005031", "005032", "005033", "005034", "005035", "005036", "005037", "005038", "005039", "005040", "005041", "005042", "005043", "005044", "005045", "005046", "005047", "005048", "005049", "005050", "005051", "005052", "005053", "005054", "005055", "005056", "005057", "005058", "005059", "005060", "005061", "005062", "005063", "005066", "005067", "005068", "005069", "005070", "005071", "005072", "005073", "005074", "005075", "005076", "005077", "005078", "005079", "005080", "005081", "005082", "005083", "005084", "005085", "005086", "005087", "005088", "005089", "005090", "005091", "005092", "005093", "005094", "005095", "005096", "005097", "005098", "005099", "005100", "005101", "005102", "005103", "005104", "005105", "005106", "005107", "005108", "005109", "005110", "005111", "005112", "005113", "005114", "005115", "005116", "005117", "005118", "005119", "005120", "005121", "005122", "005123", "005124", "005125", "005126", "005127", "005128", "005129", "005130", "005131", "005132", "005133", "005134", "005135", "005136", "005137", "005138", "005139", "005140", "005141", "005142", "005143", "005144", "005145", "005146", "005147", "005148", "005149", "005150", "005151", "005152", "005153", "005154", "005155", "005156", "005157", "005158", "005159", "005160", "005161", "005162", "005163", "005164", "005165", "005166", "005167", "005168", "005169", "005170", "005171", "005172", "005173", "005174", "005175", "005176", "005177", "005178", "005179", "005180", "005181", "005182", "005183", "005184", "005185", "005186", "005187", "005188", "005189", "005190", "005191", "005192", "005193", "005194", "005195", "005196", "005197", "005198", "005199", "005200", "005201", "005202", "005203", "005204", "005205", "005206", "005207", "005208", "005209", "005210", "005211", "005212", "005213", "005214", "005215", "005216", "005217", "005218", "005219", "005220", "005221", "005222", "005223", "005224", "005225", "005226", "005227", "005228", "005229", "005230", "005231", "005232", "005233", "005234", "005235", "005236", "005237", "005238", "005239", "005240", "005241", "005242", "005243", "005246", "005247", "005248", "005249", "005250", "005251", "005252", "005253", "005254", "005255", "005256", "005257", "005258", "005259", "005260", "005261", "005262", "005263", "005264", "005265", "005266", "005267", "005268", "005269", "005270", "005271", "005272", "005273", "005274", "005275", "005276", "005277", "005278", "005279", "005280", "005281", "005282", "005283", "005284", "005285", "005286", "005287", "005288", "005289", "005290", "005291", "005292", "005293", "005294", "005295", "005296", "005297", "005298", "005299", "005300", "005301", "005302", "005303", "005304", "005305", "005306", "005307", "005308", "005309", "005310", "005311", "005312", "005313", "005314", "005315", "005316", "005317", "005318", "005319", "005320", "005321", "005322", "005323", "005324", "005325", "005326", "005327", "005328", "005329", "005330", "005331", "005332", "005333", "005334", "005335", "005336", "005337", "005338", "005339", "005340", "005341", "005342", "005343", "005344", "005345", "005346", "005347", "005348", "005349", "005350", "005351", "005352", "005353", "005354", "005355", "005356", "005357", "005358", "005359", "005360", "005361", "005362", "005363", "005364", "005365", "005366", "005367", "005368", "005369", "005370", "005371", "005372", "005373", "005374", "005375", "005376", "005377", "005378", "005379", "005380", "005381", "005382", "005383", "005384", "005385", "005386", "005387", "005388", "005389", "005390", "005391", "005392", "005393", "005394", "005395", "005396", "005397", "005398", "005399", "005400", "005401", "005402", "005403", "005404", "005405", "005406", "005407", "005408", "005409", "005410", "005411", "005412", "005413", "005745", "005746", "005747", "005748", "005749", "005750", "005751", "005752", "005753", "005754", "005755", "005756", "005757", "005758", "005759", "005760", "005761", "005762", "005763", "005764", "005765", "005766", "005767", "005768", "005769", "005770", "005771", "005772", "005773", "005774", "005775", "005776", "005777", "005778", "005779", "005780", "005781", "005782", "005783", "005784", "005785", "005786", "005787", "005788", "005789", "005790", "005791", "005792", "005793", "005794", "005795", "005796", "005797", "005798", "005799", "005800", "005801", "005802", "005803", "005804", "005805", "005806", "005807", "005808", "005809", "005810", "005811", "005812", "005813", "005814", "005815", "005816", "005817", "005818", "005819", "005820", "005821", "005822", "005823", "005824", "005825", "005826", "005827", "005828", "005829", "005830", "005831", "005832", "005833", "005834", "005835", "005836", "005837", "005838", "005839", "005840", "005841", "005842", "005843", "005844", "005845", "005846", "005847", "005848", "005849", "005850", "005851", "005852", "005853", "005854", "005855", "005856", "005857", "005858", "005859", "005860", "005861", "005862", "005863", "005864", "005865", "005866", "005867", "005868", "005869", "005870", "005871", "005872", "005873", "005874", "005875", "005876", "005877", "005878", "005879", "005880", "005881", "005882", "005883", "005884", "005885", "005886", "005887", "005888", "005889", "005890", "005891", "005892", "005893", "005894", "005895", "005905", "005907", "005908", "005910", "005911", "005912", "005913", "005914", "005915", "005916", "006818", "006819", "006820", "006821", "006822", "006823", "006824", "006825", "006826", "006827", "006828", "006829", "006830", "006831", "006832", "006833", "006834", "006835", "006836", "006837", "006838", "006839", "006840", "006841", "006842", "006843", "006844", "006845", "006846", "006847", "006848", "006849", "006850", "006851", "006852", "006853", "006854", "006855", "006856", "006857", "006858", "006859", "006860", "006861", "006862", "006863", "006864", "006865", "006866", "006867", "006868", "006869", "006870", "006871", "006872", "006873", "006874", "006875", "006876", "006877", "006878", "006879", "006880", "006881", "006882", "006883", "006884", "006885", "006886", "006887", "006888", "006889", "006890", "006891", "006892", "006893", "006894", "006895", "006896", "006897", "006898", "006899", "006900", "006901", "006902", "006903", "006904", "006905", "006906", "006907", "006908", "006909", "006910", "006911", "006912", "006913", "006914", "006915", "006916", "006917", "006918", "006919", "006920", "006921", "006922", "006923", "006924", "006925", "006926", "006927", "006928", "006929", "006930", "006931", "006932", "006933", "006934", "006935", "006936", "006937", "006938", "006939", "006940", "006941", "006942", "006943", "006944", "006945", "006946", "006947", "006948", "006949", "006950", "006951", "006952", "006953", "006954", "006955", "006956", "006957", "006958", "006959", "006960", "006961", "006962", "006963", "006964", "006965", "006966", "006967", "006968", "006969", "006970", "006971", "006972", "006973", "006974", "006975", "006976", "006977", "006978", "006979", "006980", "006981", "006982", "006983", "006984", "006985", "006986", "006987", "006988", "006989", "006990", "006991", "006992", "006993", "006994", "006995", "006996", "006997", "006998", "006999", "007000", "007001", "007002", "007003", "007004", "007005", "007007", "007008", "007009", "007010", "007011", "007012", "007013", "007014", "007015", "007016", "007017", "007018", "007019", "007020", "007021", "007022", "007023", "007024", "007025", "007026", "007027", "007028", "007029", "007030", "007031", "007032", "007033", "007034", "007035", "007036", "007037", "007038", "007039", "007040", "007041", "007042", "007043", "007044", "007045", "007046", "007047", "007048", "007049", "007050", "007051", "007052", "007053", "007054", "007055", "007056", "007057", "007058", "007059", "007060", "007061", "007062", "007063", "007064", "007065", "007066", "007067", "007068", "007069", "007070", "007071", "007072", "007073", "007074", "007075", "007076", "007077", "007078", "007079", "007080", "007081", "007082", "007083", "007084", "007085", "007086", "007087", "007088", "007089", "007090", "007091", "007092", "007093", "007094", "007095", "007096", "007097", "007098", "007099", "007100", "007101", "007102", "007103", "007104", "007105", "007106", "007107", "007108", "007109", "007110", "007111", "007112", "007113", "007114", "007115", "007116", "007117", "007118", "007119", "007120", "007121", "007122", "007123", "007124", "007125", "007126", "007127", "007128", "007129", "007130", "007131", "007132", "007133", "007134", "007135", "007136", "007137", "007138", "007139", "007140", "007141", "007142", "007143", "007144", "007145", "007146", "007147", "007148", "007149", "007150", "007151", "007152", "007153", "007154", "007155", "007156", "007157", "007158", "007159", "007160", "007161", "007162", "007163", "007164", "007165", "007166", "007167", "007168", "007169", "007170", "007171", "007172", "007173", "007174", "007175", "007176", "007177", "007178", "007179", "007180", "007181", "007182", "007183", "007184", "007185", "007186", "007187", "007188", "007189", "007190", "007191", "007192", "007193", "007194", "007195", "007196", "007197", "007198", "007199", "007200", "007201", "007202", "007203", "007204", "007205", "007206", "007207", "007208", "007209", "007210", "007211", "007212", "007213", "007214", "007215", "007216", "007217", "007218", "007219", "007220", "007221", "007222", "007223", "007224", "007225", "007226", "007227", "007228", "007229", "007230", "007231", "007232", "007233", "007234", "007235", "007236", "007237", "007238", "007239", "007240", "007241", "007242", "007243", "007244", "007245", "007246", "007247", "007248", "007249", "007250", "007251", "007252", "007253", "007254", "007255", "007798", "007799", "007800", "007801", "007802", "007803", "007804", "007805", "007806", "007807", "007808", "007809", "007810", "007811", "007812", "007813", "007814", "007815", "007816", "007817", "007818", "007819", "007820", "007821", "007822", "007823", "007824", "007825", "007826", "007827", "007828", "007829", "007830", "007831", "007832", "007833", "007834", "007835", "007836", "007837", "007838", "007839", "007840", "007841", "007842", "007843", "007844", "007845", "007846", "007847", "007848", "007849", "007850", "007851", "007852", "007853", "007854", "007855", "007856", "007857", "007858", "007859", "007860", "007861", "007862", "007863", "007864", "007865", "007866", "007867", "007868", "007869", "007870", "007871", "007872", "007873", "007874", "007875", "007876", "007877", "007878", "007879", "007880", "007881", "007882", "007883", "007884", "007885", "007886", "007887", "007888", "007889", "007890", "007891", "007892", "007893", "007894", "007895", "007896", "007897", "007898", "007899", "007900", "007901", "007902", "007903", "007904", "007905", "007906", "007907", "007908", "007909", "007910", "007911", "007912", "007913", "007914", "007915", "007916", "007917", "007918", "007919", "007920", "007921", "007922", "007923", "007924", "007925", "007926", "007927", "007928", "007929", "007930", "007931", "007932", "007933", "007934", "007935", "007936", "007937", "007938", "007939", "007940", "007941", "007942", "007943", "007944", "007945", "007946", "007947", "007948", "007949", "007950", "007951", "007952", "007953", "007954", "007955", "007956", "007957", "007958", "007959", "007960", "007961", "007962", "007963", "007964", "007965", "007967", "007968", "007969", "007970", "007971", "007972", "007973", "007974", "007975", "007976", "007977", "007978", "007979", "007980", "007981", "007982", "007983", "007984", "007985", "007986", "007987", "007988", "007989", "007990", "007991", "007992", "007993", "007994", "007995", "007996", "007997", "007998", "007999", "008000", "008001", "008002", "008003", "008004", "008005", "008006", "008007", "008008", "008009", "008010", "008011", "008012", "008013", "008014", "008015", "008016", "008017", "008018", "008019", "008020", "008021", "008022", "008023", "008024", "008025", "008026", "008027", "008028", "008029", "008030", "008031", "008032", "008033", "008034", "008035", "008036", "008037", "008038", "008039", "008040", "008041", "008042", "008043", "008044", "008045", "008046", "008047", "008048", "008049", "008050", "008051", "008052", "008053", "008054", "008055", "008056", "008057", "008058", "008060", "008061", "008062", "008063", "008064", "008065", "008066", "008073", "008087", "008088", "008089", "008090", "008091", "008092", "008093", "008094", "008095", "008096", "008097", "008098", "008099", "008100", "008101", "008102", "008103", "008104", "008105", "008106", "008107", "008108", "008109", "008110", "008111", "008112", "008113", "008114", "008115", "008116", "008117", "008118", "008119", "008120", "008121", "008122", "008123", "008124", "008125", "008126", "008127", "008128", "008129", "008130", "008131", "008132", "008133", "008134", "008135", "008136", "008137", "008138", "008139", "008140", "008141", "008142", "008143", "008144", "008145", "008146", "008147", "008148", "008149", "008150", "008151", "008152", "008153", "008154", "008155", "008156", "008157", "008158", "008159", "008160", "008161", "008162", "008163", "008164", "008165", "008166", "008167", "008168", "008169", "008170", "008171", "008172", "008173", "008174", "008175", "008176", "008177", "008178", "008179", "008180", "008181", "008182", "008183", "008184", "008185", "008186", "008187", "008188", "008189", "008190", "008191", "008192", "008193", "008194", "008195", "008196", "008197", "008198", "008199", "008200", "008201", "008202", "008203", "008204", "008205", "008206", "008207", "008208", "008209", "008210", "008211", "008212", "008213", "008214", "008215", "008216", "008217", "008218", "008219", "008220", "008221", "008222", "008223", "008224", "008225", "008226", "008227", "008228", "008229", "008230", "008231", "008232", "008233", "008234", "008235", "008236", "008237", "008238", "008239", "008240", "008241", "008242", "008243", "008244", "008245", "008246", "008247", "008248", "008249", "008250", "008251", "008252", "008253", "008254", "008255", "008256", "008257", "008258", "008259", "008260", "008261", "008262", "008263", "008264", "008265", "008266", "008277", "008278", "008279", "008280", "008281", "008282", "008283", "008284", "008285", "008287", "008288", "008289", "008290", "008291", "008292", "008293", "008294", "008295", "008296", "008297", "008298", "008299", "008300", "008301", "008302", "008303", "008304", "008305", "008306", "008307", "008308", "008309", "008310", "008311", "008312", "008313", "008314", "008315", "008316", "008317", "008318", "008319", "008320", "008321", "008322", "008323", "008324", "008325", "008326", "008327", "008328", "008329", "008330", "008331", "008332", "008333", "008334", "008335", "008336", "008337", "008338", "008339", "008340", "008341", "008342", "008343", "008344", "008345", "008346", "008347", "008348", "008349", "008350", "008351", "008352", "008353", "008354", "008355", "008356", "008357", "008358", "008359", "008360", "008361", "008362", "008363", "008364", "008365", "008366", "008367", "008368", "008369", "008370", "008371", "008372", "008373", "008374", "008375", "008376", "008377", "008378", "008379", "008380", "008381", "008382", "008383", "008384", "008385", "008386", "008387", "008388", "008389", "008390", "008391", "008392", "008393", "008394", "008395", "008396", "008397", "008398", "008399", "008400", "008401", "008402", "008403", "008404", "008405", "008406", "008407", "008408", "008409", "008410", "008411", "008412", "008413", "008414", "008415", "008416", "008417", "008418", "008419", "008420", "008421", "008422", "008423", "008424", "008425", "008426", "008427", "008428", "008429", "008430", "008431", "008432", "008433", "008434", "008435", "008436", "008437", "008438", "008439", "008440", "008441", "008442", "008443", "008444", "008445", "008446", "008447", "008448", "008449", "008450", "008451", "008452", "008453", "008454", "008455", "008456", "008457", "008458", "008459", "008460", "008461", "008462", "008463", "008464", "008465", "008466", "008467", "008468", "008469", "008470", "008471", "008472", "008473", "008474", "008475", "009152", "009153", "009154", "009155", "009156", "009157", "009158", "009159", "009160", "009161", "009162", "009163", "009164", "009165", "009166", "009167", "009168", "009169", "009170", "009171", "009172", "009173", "009174", "009175", "009176", "009177", "009178", "009179", "009180", "009181", "009182", "009183", "009184", "009185", "009186", "009187", "009188", "009189", "009190", "009191", "009192", "009193", "009194", "009195", "009196", "009197", "009198", "009199", "009200", "009201", "009202", "009203", "009204", "009205", "009206", "009207", "009208", "009209", "009210", "009211", "009212", "009213", "009214", "009215", "009216", "009217", "009218", "009219", "009220", "009221", "009222", "009223", "009224", "009225", "009226", "009227", "009228", "009229", "009230", "009231", "009232", "009233", "009234", "009235", "009236", "009237", "009238", "009239", "009240", "009241", "009242", "009243", "009244", "009245", "009246", "009247", "009248", "009249", "009250", "009251", "009252", "009253", "009254", "009255", "009256", "009257", "009258", "009259", "009260", "009261", "009262", "009263", "009264", "009265", "009266", "009267", "009268", "009269", "009270", "009271", "009272", "009273", "009274", "009275", "009276", "009277", "009278", "009279", "009280", "009281", "009282", "009283", "009284", "009285", "009286", "009287", "009288", "009289", "009290", "009291", "009292", "009293", "009294", "009295", "009296", "009297", "009298", "009299", "009300", "009301", "009302", "009303", "009304", "009305", "009306", "009307", "009308", "009309", "009310", "009311", "009312", "009313", "009314", "009315", "009316", "009317", "009318", "009319", "009320", "009321", "009322", "009323", "009324", "009325", "009326", "009327", "009328", "009329", "009330", "009331", "009332", "009333", "009334", "009335", "009336", "009337", "009338", "009339", "009340", "009341", "009342", "009343", "009344", "009345", "009346", "009347", "009348", "009349", "009350", "009351", "009352", "009353", "009354", "009355", "009356", "009357", "009358", "009359", "009360", "009502", "009503", "009504", "009505", "009506", "009507", "009508", "009509", "009510", "009511", "009512", "009513", "009514", "009515", "009516", "009517", "009518", "009519", "009520", "009521", "009522", "009523", "009524", "009525", "009526", "009527", "009528", "009529", "009530", "009531", "009532", "009533", "009534", "009535", "009536", "009537", "009538", "009539", "009540", "009541", "009542", "009543", "009544", "009545", "009546", "009547", "009548", "009549", "009550", "009551", "009552", "009553", "009554", "009555", "009556", "009557", "009558", "009559", "009560", "009561", "009562", "009563", "009564", "009565", "009566", "009567", "009568", "009569", "009570", "009571", "009572", "009573", "009574", "009575", "009576", "009577", "009578", "009579", "009580", "009581", "009582", "009583", "009584", "009585", "009586", "009587", "009588", "009589", "009590", "009591", "009594", "009595", "009596", "009597", "009598", "009599", "009600", "009601", "009602", "009603", "009604", "009605", "009606", "009607", "009608", "009609", "009610", "009611", "009612", "009613", "009614", "009615", "009616", "009617", "009618", "009619", "009620", "009621", "009622", "009623", "009624", "009625", "009626", "009627", "009628", "009629", "009630", "009631", "009632", "009633", "009634", "009635", "009636", "009637", "009638", "009639", "009640", "009641", "009642", "009643", "009644", "009645", "009646", "009647", "009648", "009649", "009650", "009651", "009652", "009653", "009654", "009655", "009656", "009657", "009658", "009659", "009660", "009661", "009662", "009663", "009664", "009665", "009666", "009667", "009668", "009669", "009670", "009671", "009672", "009673", "009674", "009675", "009676", "009677", "009678", "009679", "009680", "009681", "009682", "009683", "009684", "009685", "009686", "009687", "009688", "009689", "009690", "011742", "011743", "011744", "011745", "011746", "011747", "011748", "011749", "011750", "011751", "011752", "011753", "011754", "011755", "011756", "011757", "011758", "011759", "011760", "011761", "011762", "011763", "011764", "011765", "011766", "011767", "011768", "011769", "011770", "011771", "011772", "011773", "011774", "011775", "011776", "011777", "011778", "011779", "011780", "011781", "011782", "011783", "011784", "011785", "011786", "011787", "011788", "011789", "011790", "011791", "011792", "011793", "011794", "011795", "011796", "011797", "011798", "011799", "011800", "011801", "011802", "011803", "011804", "011805", "011806", "011807", "011808", "011809", "011810", "011811", "011812", "011813", "011814", "011815", "011816", "011817", "011818", "011819", "011820", "011821", "011822", "011823", "011824", "011825", "011826", "011827", "011828", "011829", "011830", "011833", "011834", "011835", "011836", "011837", "011838", "011839", "011840", "011841", "011842", "011843", "011844", "011845", "011846", "011847", "011848", "011849", "011850", "011851", "011852", "011853", "011854", "011855", "011856", "011857", "011858", "011859", "011860", "011861", "011862", "011863", "011864", "011865", "011866", "011867", "011868", "011869", "011870", "011871", "011872", "011873", "011874", "011875", "011876", "011877", "011878", "011879", "011880", "011881", "011882", "011883", "011884", "011885", "011886", "011887", "011888", "011889", "011890", "011891", "011892", "011893", "011894", "011895", "011896", "011897", "011898", "011899", "011900", "011901", "011902", "011903", "011904", "011905", "011906", "011907", "011908", "011909", "011910", "011911", "011912", "011913", "011914", "011915", "011916", "011917", "011918", "011919", "011920", "011921", "011922", "011923", "011924", "011925", "011926", "011927", "011928", "011929", "011930", "011931", "011932", "011933", "011934", "011935", "011936", "011937", "011938", "011939", "011940", "011941", "011942", "011943", "011944", "011945", "011946", "011947", "011948", "011949", "011950", "011951", "011952", "011953", "011954", "011955", "011956", "011957", "011958", "011959", "011960", "011961", "011962", "011963", "011964", "011965", "011966", "011967", "011968", "011969", "011970", "011971", "011972", "011973", "011974", "011975", "011976", "011977", "011978", "011979", "011980", "011981", "011982", "011983", "011984", "011985", "011986", "011987", "011988", "011989", "011990", "011991", "011992", "011993", "011994", "011995", "011996", "011997", "011998", "011999", "012000", "012001", "012002", "012003", "012004", "012005", "012006", "012007", "012008", "012009", "012010", "012011", "012012", "012013", "012014", "012015", "012016", "012017", "012018", "012019", "012020", "012021", "012022", "012023", "012024", "012025", "012026", "012027", "012028", "012029", "012030", "012031", "012032", "012033", "012034", "012035", "012036", "012037", "012038", "012039", "012040", "012041", "012042", "012043", "012044", "012045", "012046", "012047", "012048", "012049", "012050", "012051", "012052", "012053", "012054", "012055", "012056", "012057", "012058", "012059", "012060", "012061", "012062", "012063", "012064", "012065", "012066", "012067", "012068", "012069", "012070", "012071", "012072", "012073", "012074", "012075", "012076", "012077", "012078", "012079", "012080", "012081", "012082", "012083", "012084", "012085", "012086", "012087", "012088", "012089", "012090", "012299", "012300", "012301", "012302", "012303", "012304", "012305", "012306", "012307", "012308", "012309", "012310", "012311", "012312", "012313", "012314", "012315", "012316", "012317", "012318", "012319", "012320", "012321", "012322", "012323", "012324", "012325", "012326", "012327", "012328", "012329", "012330", "012331", "012332", "012333", "012334", "012335", "012336", "012337", "012338", "012339", "012340", "012341", "012342", "012343", "012344", "012345", "012346", "012347", "012348", "012349", "012350", "012351", "012352", "012353", "012354", "012355", "012356", "012357", "012358", "012359", "012360", "012361", "012362", "012363", "012364", "012365", "012366", "012367", "012368", "012369", "012370", "012371", "012372", "012373", "012374", "012375", "012376", "012377", "012378", "012379", "012380", "012381", "012382", "012383", "012384", "012385", "012386", "012387", "012388", "012389", "012390", "012391", "012392", "012393", "012394", "012395", "012396", "012397", "012398", "012399", "012400", "012401", "012402", "012403", "012404", "012405", "012406", "012407", "012408", "012409", "012410", "012411", "012412", "012413", "012414", "012415", "012416", "012417", "012418", "012419", "012420", "012421", "012422", "012423", "012424", "012425", "012426", "012427", "012428", "012429", "012430", "012431", "012432", "012433", "012434", "012435", "012436", "012437", "012438", "012439", "012440", "012441", "012442", "012821", "012822", "012823", "012824", "012825", "012826", "012827", "012828", "012829", "012830", "012831", "012832", "012833", "012834", "012835", "012836", "012837", "012838", "012839", "012840", "012841", "012842", "012843", "012844", "012845", "012846", "012847", "012848", "012849", "012850", "012851", "012852", "012853", "012854", "012855", "012856", "012857", "012858", "012859", "012860", "012861", "012862", "012863", "012864", "012865", "012866", "012867", "012868", "012869", "012870", "012871", "012872", "012873", "012874", "012875", "012876", "012877", "012878", "012879", "012880", "012881", "012882", "012883", "012884", "012885", "012886", "012887", "012888", "012889", "012890", "012891", "012892", "012893", "012894", "012895", "012896", "012897", "012898", "012899", "012900", "012901", "012902", "012903", "012904", "012905", "012906", "012907", "012908", "012909", "012910", "012911", "012912", "012913", "012914", "012915", "012916", "012917", "012918", "012919", "012920", "012921", "012922", "012923", "012924", "012925", "012927", "012928", "012929", "012930", "012931", "012932", "012933", "012934", "012935", "012936", "012937", "012938", "012939", "012940", "012941", "012942", "012943", "012944", "012945", "012946", "012947", "012948", "012949", "012950", "012951", "012952", "012953", "012954", "012955", "012956", "012957", "012958", "012959", "012960", "012961", "012962", "012963", "012964", "012965", "012966", "012967", "012968", "012969", "012970", "012971", "012972", "012973", "012974", "012975", "012976", "012977", "012978", "012979", "012980", "012981", "012982", "012983", "012984", "012985", "012986", "012987", "012988", "012989", "012990", "012991", "012992", "012993", "012995", "012996", "012997", "012998", "012999", "013000", "013890", "013891", "013892", "013893", "013894", "013895", "013896", "013897", "013898", "013899", "013900", "013901", "013902", "013903", "013904", "013905", "013906", "013907", "013908", "013909", "013910", "013911", "013912", "013913", "013914", "013915", "013916", "013917", "013918", "013919", "013920", "013921", "013922", "013923", "013924", "013925", "013926", "013927", "013928", "013929", "013930", "013931", "013932", "013933", "013934", "013935", "013936", "013937", "014048", "014049", "014050", "014051", "014052", "014053", "014054", "014055", "014056", "014057", "014058", "014059", "014060", "014061", "014062", "014063", "014064", "014065", "014066", "014067", "014068", "014069", "014070", "014071", "014072", "014073", "014074", "014075", "014076", "014077", "014078", "014079", "014080", "014081", "014082", "014083", "014084", "014085", "014086", "014087", "014088", "014089", "014090", "014091", "014092", "014093", "014094", "014095", "014096", "014097", "014098", "014099", "014100", "014101", "014102", "014103", "014104", "014105", "014106", "014107", "014108", "014109", "014110", "014111", "014112", "014113", "014114", "014115", "014116", "014117", "014118", "014119", "014120", "014121", "014122", "014123", "014124", "014125", "014126", "014127", "014128", "014129", "014130", "014131", "014132", "014133", "014134", "014135", "014136", "014137", "014138", "014139", "014140", "014141", "014142", "014143", "014144", "014145", "014146", "014147", "014148", "014149", "014150", "014151", "014152", "014153", "014154", "014155", "014156", "014157", "015217", "015218", "015219", "015220", "015221", "015222", "015223", "015224", "015225", "015226", "015227", "015228", "015229", "015230", "015231", "015232", "015233", "015234", "015235", "015236", "015237", "015238", "015239", "015240", "015241", "015242", "015243", "015244", "015245", "015246", "015247", "015248", "015249", "015250", "015251", "015252", "015253", "015254", "015255", "015256", "015257", "015258", "015259", "015260", "015261", "015262", "015263", "015264", "015265", "015266", "015267", "015268", "015269", "015270", "015271", "015272", "015273", "015274", "015275", "015276", "015277", "015278", "015279", "015280", "015281", "015282", "015283", "015284", "015285", "015286", "015287", "015288", "015289", "015290", "015291", "015292", "015293", "015294", "015295", "015296", "015297", "016269", "016270", "016271", "016272", "016273", "016274", "016275", "016276", "016277", "016278", "016279", "016280", "016281", "016282", "016283", "016284", "016285", "016286", "016287", "016288", "016289", "016290", "016291", "016292", "016293", "016294", "016295", "016296", "016297", "016298", "016299", "016300", "016301", "016302", "016303", "016304", "016305", "016306", "016307", "016308", "016309", "016310", "016311", "016312", "016313", "016314", "016315", "016316", "016317", "016318", "016319", "016320", "016321", "016322", "016323", "016324", "016325", "016326", "016327", "016328", "016329", "016330", "016331", "016332", "016333", "016334", "016335", "016336", "016337", "016338", "016339", "016340", "016341", "016342", "016343", "016344", "016345", "016346", "016347", "016348", "016349", "016350", "016351", "016352", "016353", "016354", "016355", "016356", "016357", "016358", "016359", "016360", "016361", "016362", "016363", "016364", "016365", "016366", "016367", "016368", "016369", "016370", "016371", "016372", "016373", "016374", "016375", "016376", "016377", "016378", "016379", "016380", "016381", "016382", "016383", "016384", "016385", "016386", "016387", "016388", "016393", "016394", "016395", "016396", "016397", "016398", "016399", "016400", "016401", "016402", "016403", "016404", "016405", "016406", "016408", "016409", "016410", "016411", "016412", "016413", "016414", "016415", "016416", "016417", "016418", "016419", "016420", "016421", "016422", "016423", "016424", "016425", "016426", "016427", "016428", "016429", "016430", "016431", "016432", "016433", "016434", "016435", "016436", "016437", "016438", "016439", "016440", "016441", "016442", "016443", "016444", "016445", "016446", "016447", "016448", "016449", "016450", "016451", "016452", "016453", "016454", "016455", "016456", "016457", "016458", "016459", "016460", "016461", "016462", "016463", "016464", "016465", "016466", "016467", "016468", "016469", "016470", "016471", "016472", "016473", "016474", "016475", "016476", "016477", "016478", "016479", "016480", "016481", "016482", "016483", "016484", "016485", "016486", "016487", "016488", "016489", "016490", "016491", "016492", "016493", "016494", "016495", "016496", "016497", "016498", "016499", "016500", "016501", "016502", "016503", "016504", "016505", "016506", "016507", "016509", "016510", "016511", "016512", "016513", "016514", "016515", "016516", "016517", "016518", "016519", "016520", "016521", "016522", "016523", "016524", "016525", "016526", "016527", "016528", "016529", "016530", "016531", "016532", "016533", "016534", "016535", "016536", "016537", "016538", "016539", "016540", "016541", "016542", "016543", "016544", "016545", "016546", "016547", "016548", "016549", "016550", "016551", "016552", "016553", "016554", "016555", "016556", "016557", "016558", "016559", "016560", "016561", "016562", "016563", "016564", "016565", "016566", "016567", "016568", "016569", "016570", "016571", "016572", "016573", "016574", "016575", "016576", "016577", "016578", "016579", "016580", "016581", "016582", "016583", "016584", "016585", "016586", "016587", "016588", "016589", "016590", "016591", "016592", "016593", "016594", "016595", "016596", "016597", "016598", "016599", "016600", "016601", "016602", "016603", "016604", "016605", "016606", "016607", "016608", "016609", "016610", "016611", "016612", "016613", "016614", "016615", "016616", "016617", "016618", "016619", "016620", "016621", "016622", "016623", "016624", "016625", "016626", "016627", "016628", "016629", "016630", "016631", "016632", "016633", "016634", "016635", "016636", "016637", "016638", "016639", "016640", "016641", "016642", "016643", "016644", "016645", "016646", "016647", "016648", "016649", "016650", "016651"], "test_A": ["002075", "002076", "002077", "002078", "002079", "002080", "002081", "002082", "002083", "002084", "002085", "002086", "002087", "002088", "002089", "002090", "002091", "002092", "002093", "002094", "002095", "002096", "002097", "002098", "002099", "002100", "002101", "002102", "002103", "002104", "002105", "002106", "002107", "002108", "002109", "002110", "002111", "002112", "002113", "002114", "002115", "002116", "002117", "002118", "002119", "002120", "002121", "002122", "002123", "002124", "002125", "002126", "002127", "002128", "002129", "002130", "002131", "002132", "002133", "002134", "002135", "002136", "002137", "002138", "002139", "002140", "002141", "002142", "002143", "002144", "002145", "002146", "002147", "002148", "002149", "002150", "002151", "002152", "002153", "002154", "002155", "002156", "002157", "002158", "002159", "002160", "002161", "002162", "002163", "002164", "002165", "002166", "002167", "002168", "002169", "002170", "002171", "002172", "002173", "002174", "002175", "002176", "002177", "002178", "002179", "002180", "002181", "002182", "002183", "002184", "002185", "002186", "002187", "002188", "002189", "002190", "002191", "002192", "002193", "002194", "002195", "002196", "002197", "002198", "002199", "002200", "002201", "002202", "002203", "002204", "002205", "002206", "002207", "002208", "002209", "002210", "002211", "002212", "002213", "002214", "002231", "002233", "002235", "002236", "002237", "002238", "002239", "002240", "002241", "002242", "002243", "002693", "002694", "002695", "002696", "002697", "002698", "002699", "002700", "002701", "002702", "002703", "002704", "002705", "002706", "002707", "002708", "002709", "002710", "002711", "002712", "002713", "002714", "002715", "002716", "002717", "002718", "002719", "002720", "002721", "002722", "002723", "002724", "002725", "002726", "002727", "002728", "002729", "002730", "002731", "002732", "002733", "002734", "002735", "002736", "002737", "002738", "002739", "002740", "002741", "002742", "002743", "002744", "002745", "002746", "002747", "002748", "002749", "002750", "002751", "002752", "002753", "002754", "002755", "002756", "002757", "002758", "002759", "002760", "002761", "002762", "002763", "002764", "002765", "002766", "002767", "002768", "002769", "002770", "002771", "002772", "002773", "002774", "002775", "002776", "002777", "002778", "002779", "002780", "002781", "002782", "002784", "002785", "002786", "002787", "002788", "002789", "002790", "002791", "002792", "002793", "002794", "002795", "002796", "002797", "002798", "002799", "002800", "002801", "002802", "002803", "002804", "002805", "002806", "002807", "002808", "002809", "002810", "002811", "002812", "002813", "002814", "002815", "002816", "002817", "002818", "002819", "002820", "002821", "002822", "002823", "002824", "002825", "002826", "002827", "002828", "002829", "002830", "002831", "002832", "002833", "002834", "002835", "002836", "002837", "002838", "002839", "002840", "002841", "002842", "002843", "002844", "002845", "002846", "002847", "002848", "002849", "002850", "002851", "002852", "002853", "002854", "002855", "002856", "002857", "002858", "002859", "002860", "002861", "004886", "004887", "004888", "004889", "004890", "004891", "004892", "004893", "004894", "004895", "004896", "004897", "004898", "004899", "004900", "004901", "004902", "004903", "004904", "004905", "004906", "004907", "004908", "004909", "004910", "004911", "004912", "004913", "004914", "004915", "004916", "004917", "004918", "004919", "004920", "004921", "004922", "004923", "004924", "004925", "004926", "004927", "004928", "004929", "004930", "004931", "004932", "004933", "004934", "004935", "004936", "004937", "004938", "004939", "004940", "004941", "004942", "004943", "004944", "004945", "004946", "004947", "004948", "004949", "004950", "004951", "004952", "004953", "004954", "004955", "004956", "004957", "004958", "004959", "004960", "004961", "004962", "004963", "004964", "004965", "004966", "004967", "004968", "004969", "004970", "004971", "004972", "004973", "004974", "004975", "004976", "004977", "004978", "004979", "004980", "004981", "004982", "004983", "004984", "004985", "004986", "004987", "004988", "004989", "004990", "004991", "004992", "004993", "004994", "004995", "004996", "004997", "004998", "004999", "005000", "005001", "005002", "005003", "005004", "005005", "005006", "005007", "005008", "005009", "005010", "005011", "005012", "005013", "005014", "005015", "005016", "005017", "005018", "005019", "005020", "005021", "005022", "005023", "005024", "005025", "005026", "005027", "005028", "005029", "005030", "005031", "005032", "005033", "005034", "005035", "005036", "005037", "005038", "005039", "005040", "005041", "005042", "005043", "005044", "005045", "005046", "005047", "005048", "005049", "005050", "005051", "005052", "005053", "005054", "005055", "005056", "005057", "005058", "005059", "005060", "005061", "005062", "005063", "006818", "006819", "006820", "006821", "006822", "006823", "006824", "006825", "006826", "006827", "006828", "006829", "006830", "006831", "006832", "006833", "006834", "006835", "006836", "006837", "006838", "006839", "006840", "006841", "006842", "006843", "006844", "006845", "006846", "006847", "006848", "006849", "006850", "006851", "006852", "006853", "006854", "006855", "006856", "006857", "006858", "006859", "006860", "006861", "006862", "006863", "006864", "006865", "006866", "006867", "006868", "006869", "006870", "006871", "006872", "006873", "006874", "006875", "006876", "006877", "006878", "006879", "006880", "006881", "006882", "006883", "006884", "006885", "006886", "006887", "006888", "006889", "006890", "006891", "006892", "006893", "006894", "006895", "006896", "006897", "006898", "006899", "006900", "006901", "006902", "006903", "006904", "006905", "006906", "006907", "006908", "006909", "006910", "006911", "006912", "006913", "006914", "006915", "006916", "006917", "006918", "006919", "006920", "006921", "006922", "006923", "006924", "006925", "006926", "006927", "006928", "006929", "006930", "006931", "006932", "006933", "006934", "006935", "006936", "006937", "006938", "006939", "006940", "006941", "006942", "006943", "006944", "006945", "006946", "006947", "006948", "006949", "006950", "006951", "006952", "006953", "006954", "006955", "006956", "006957", "006958", "006959", "006960", "006961", "006962", "006963", "006964", "006965", "006966", "006967", "006968", "006969", "006970", "006971", "006972", "006973", "006974", "006975", "006976", "006977", "006978", "006979", "006980", "006981", "006982", "006983", "006984", "006985", "006986", "006987", "006988", "006989", "006990", "006991", "006992", "006993", "006994", "006995", "006996", "006997", "006998", "006999", "007000", "007001", "007002", "007003", "007004", "007005", "007967", "007968", "007969", "007970", "007971", "007972", "007973", "007974", "007975", "007976", "007977", "007978", "007979", "007980", "007981", "007982", "007983", "007984", "007985", "007986", "007987", "007988", "007989", "007990", "007991", "007992", "007993", "007994", "007995", "007996", "007997", "007998", "007999", "008000", "008001", "008002", "008003", "008004", "008005", "008006", "008007", "008008", "008009", "008010", "008011", "008012", "008013", "008014", "008015", "008016", "008017", "008018", "008019", "008020", "008021", "008022", "008023", "008024", "008025", "008026", "008027", "008028", "008029", "008030", "008031", "008032", "008033", "008034", "008035", "008036", "008037", "008038", "008039", "008040", "008041", "008042", "008043", "008044", "008045", "008046", "008047", "008048", "008049", "008050", "008051", "008052", "008053", "008054", "008055", "008056", "008057", "008058", "008060", "008061", "008062", "008063", "008064", "008065", "008066", "008073", "012299", "012300", "012301", "012302", "012303", "012304", "012305", "012306", "012307", "012308", "012309", "012310", "012311", "012312", "012313", "012314", "012315", "012316", "012317", "012318", "012319", "012320", "012321", "012322", "012323", "012324", "012325", "012326", "012327", "012328", "012329", "012330", "012331", "012332", "012333", "012334", "012335", "012336", "012337", "012338", "012339", "012340", "012341", "012342", "012343", "012344", "012345", "012346", "012347", "012348", "012349", "012350", "012351", "012352", "012353", "012354", "012355", "012356", "012357", "012358", "012359", "012360", "012361", "012362", "012363", "012364", "012365", "012366", "012367", "012368", "012369", "012370", "012371", "012372", "012373", "012374", "012375", "012376", "012377", "012378", "012379", "012380", "012381", "012382", "012383", "012384", "012385", "012386", "012387", "012388", "012389", "012390", "012391", "012392", "012393", "012394", "012395", "012396", "012397", "012398", "012399", "012400", "012401", "012402", "012403", "012404", "012405", "012406", "012407", "012408", "012409", "012410", "012411", "012412", "012413", "012414", "012415", "012416", "012417", "012418", "012419", "012420", "012421", "012422", "012423", "012424", "012425", "012426", "012427", "012428", "012429", "012430", "012431", "012432", "012433", "012434", "012435", "012436", "012437", "012438", "012439", "012440", "012441", "012442", "014048", "014049", "014050", "014051", "014052", "014053", "014054", "014055", "014056", "014057", "014058", "014059", "014060", "014061", "014062", "014063", "014064", "014065", "014066", "014067", "014068", "014069", "014070", "014071", "014072", "014073", "014074", "014075", "014076", "014077", "014078", "014079", "014080", "014081", "014082", "014083", "014084", "014085", "014086", "014087", "014088", "014089", "014090", "014091", "014092", "014093", "014094", "014095", "014096", "014097", "014098", "014099", "014100", "014101", "014102", "014103", "014104", "014105", "014106", "014107", "014108", "014109", "014110", "014111", "014112", "014113", "014114", "014115", "014116", "014117", "014118", "014119", "014120", "014121", "014122", "014123", "014124", "014125", "014126", "014127", "014128", "014129", "014130", "014131", "014132", "014133", "014134", "014135", "014136", "014137", "014138", "014139", "014140", "014141", "014142", "014143", "014144", "014145", "014146", "014147", "014148", "014149", "014150", "014151", "014152", "014153", "014154", "014155", "014156", "014157", "016509", "016510", "016511", "016512", "016513", "016514", "016515", "016516", "016517", "016518", "016519", "016520", "016521", "016522", "016523", "016524", "016525", "016526", "016527", "016528", "016529", "016530", "016531", "016532", "016533", "016534", "016535", "016536", "016537", "016538", "016539", "016540", "016541", "016542", "016543", "016544", "016545", "016546", "016547", "016548", "016549", "016550", "016551", "016552", "016553", "016554", "016555", "016556", "016557", "016558", "016559", "016560", "016561", "016562", "016563", "016564", "016565", "016566", "016567", "016568", "016569", "016570", "016571", "016572", "016573", "016574", "016575", "016576", "016577", "016578", "016579", "016580", "016581", "016582", "016583", "016584", "016585", "016586", "016587", "016588", "016589", "016590", "016591", "016592", "016593", "016594", "016595", "016596", "016597", "016598", "016599", "016600", "016601", "016602", "016603", "016604", "016605", "016606", "016607", "016608", "016609", "016610", "016611", "016612", "016613", "016614", "016615", "016616", "016617", "016618", "016619", "016620", "016621", "016622", "016623", "016624", "016625", "016626", "016627", "016628", "016629", "016630", "016631", "016632", "016633", "016634", "016635", "016636", "016637", "016638", "016639", "016640", "016641", "016642", "016643", "016644", "016645", "016646", "016647", "016648", "016649", "016650", "016651"]}} \ No newline at end of file diff --git a/docs/apis/dataloaders_spd.md b/docs/apis/dataloaders_spd.md new file mode 100644 index 0000000..052654b --- /dev/null +++ b/docs/apis/dataloaders_spd.md @@ -0,0 +1,120 @@ +## SPD Dataset + +We provide four spd dataset classes, namely `VICSyncDatasetSPD`, `VICAsyncDatasetSPD`, `DAIRV2XVSPD` and `DAIRV2XISPD`. +All the datasets are the subclass of `torch.utils.data.dataset.Dataset`. +You can construct them with the following code: +``` +dataset = SUPPROTED_DATASETS[dataset](path, split, sensortype, extended_range) +``` +- **dataset** refers to the dataset type including `vic-sync-spd`, `vic-async-spd`, `dair-v2x-v-spd` and `dair-v2x-i-spd`. + +- **path** refers to the directory where SPD dataset is stored. + +- **split** refers to the dataset split. Available choices are `train`, `val`, `test` and `valtest`. + +- **sensortype** refers to the different sensor. `lidar` and `camera` are supported now. + +- **extended_range** is a bounding box denoted as [minx, miny, minz, maxx, maxy, maxz], which represents the intrested area (which is often an extension of the vehicle's range of point cloud) under the vehicle LiDAR coordinate system. Vehicles outside the specific box will be filtered out. + +### Format +We take `vic-sync-spd` as an example. Each element of the `vic-sync-spd` is a tuple. You can enumerate all data frames in the following way: +``` +for VICFrameSPD, label, filt in dataset: + # Your code here +``` +#### VICFrameSPD +You can access to the infrastructure frame class or vehicle frame class by: +``` +VICFrameSPD.inf_frame # The infrastructure frame, member of InfFrameSPD +VICFrameSPD.veh_frame # The vehicle frame, member of VehFrameSPD +``` +We provide `Transform` class carrying out the coordinate transformation you need: +``` +trans=VICFrameSPD.transform("from_coord","to_coord") +point_new=trans(point) +``` +The following coordinate transformation are supported: +``` +Infrastructure_image ->'Infrastructure_camera'->'Infrastructure_lidar'->'world' + ^ + | + 'Vehicle_image'->'Vehicle_camera'->'Vehicle_lidar'->'Vehicle_novatel' + +``` +note: In SPD, when converting from the Infrastructure_lidar to Vehicle_lidar, the usage of delta_x and delta_y in the system_error_offset is different from that in VIC3D. + +You can access the VICFrameSPD values by their keys: + +| Key | Value | +|---------------------------|-----------------------------------------------------------------------------| +| `infrastructure_frame` | infrastructure frame datainfo | +| `vehicle_frame` | vehicle frame datainfo | + +#### InfFrameSPD + +`InfFrameSPD` refers to the infrastructure frame class. We provide APIs which loads the point cloud (`inf_frame.point_cloud(data_format="array"/"file"/"tensor")`) or image (`inf_frame.image(data_format="array"/"file"/"tensor")`) of this frame. + +You can also access the frame values by their keys which are listed below: + +| Key | Value | +|-------------------------------------|----------------------------------------------------------------------------------------------| +| `image_path` | path to the image | +| `image_timestamp` | the timestamp of the image | +| `pointcloud_path` | path to point cloud | +| `pointcloud_timestamp` | the timestamp of the point cloud | +| `label_lidar_std_path` | path to the annotation of point cloud | +| `label_camera_std_path` | path to the annotation of image | +| `calib_virtuallidar_to_world_path` | path of the calibration file from virtuallidar coordinate system to world coordinate system | +| `calib_virtuallidar_to_camera_path` | path of the calibration file from virtuallidar coordinate system to camera coordinate system | +| `calib_camera_intrisinc_path` | path of the camera intrinsics file | +| `frame_id` | id of the current frame | +| `sequence_id` | id of the current sequence | +| `num_frames` | number of the continuous frames | +| `start_frame_id` | start id of the continuous frames | +| `end_frame_id` | end id of the continuous frames | +| `intersection_loc` | name of the intersection | +| `camera_ip` | ip of the camera | +| `camera_id` | id of the camera | +| `lidar_id` | id of the LiDAR | + + +#### VehFrameSPD + +`VehFrameSPD` refers to the vehicle frame class. We provide APIs which loads the point cloud (`veh_frame.point_cloud(data_format="array"/"file"/"tensor")`) or image (`veh_frame.image(data_format="array"/"file"/"tensor")`) of this frame. +You can also access the frame values by their keys listed below: + +| Key | Value | +|-------------------------------|----------------------------------------------------------------------------------------| +| `image_path` | path to the image | +| `image_timestamp` | the timestamp of the image | +| `pointcloud_path` | path to point cloud | +| `pointcloud_timestamp` | the timestamp of the point cloud | +| `label_lidar_std_path` | path to the annotation of point cloud | +| `label_camera_std_path` | path to the annotation of image | +| `calib_lidar_to_camera_path` | path of the calibration file from lidar coordinate system to camera coordinate system | +| `calib_lidar_to_novatel_path` | path of the calibration file from lidar coordinate system to NovAtel coordinate system | +| `calib_novatel_to_world_path` | path of the calibration file from NovAtel coordinate system to world coordinate system | +| `calib_camera_intrisinc_path` | path of the camera intrinsics file | +| `frame_id` | id of the current frame | +| `sequence_id` | id of the current sequence | +| `num_frames` | number of the continuous frames | +| `start_frame_id` | start id of the continuous frames | +| `end_frame_id` | end id of the continuous frames | +| `intersection_loc` | name of the intersection | + +#### Label + +`label` refers to the vehicle-infrastructure collaborative annotations, based on Vehicle LiDAR coordinate system. The format of which is as followings. + +| Key | Value | +|-------------|--------------------------------------------------------------------------------------------------------| +| `boxes_3d` | Numpy Float64 Array, [N, 8, 3], representing the 3D bounding box | +| `labels_3d` | Numpy String Array, [N], representing the class of each vehicle (including `car`, `van`,`truck`,`bus`) | +| `scores_3d` | Numpy Float64 Array, which is all 1 in label | + + +#### Filt + +`filt` is a filter which decides if the prediction box should be retained since that we are only intrested in boxes within `extended_range`. + + diff --git a/docs/get_started_spd.md b/docs/get_started_spd.md new file mode 100644 index 0000000..b2ec773 --- /dev/null +++ b/docs/get_started_spd.md @@ -0,0 +1,180 @@ +## Get Started with V2X-Seq-SPD + +### Installation + +a. Required extertal packages are listed as follows: + +``` +mmdetection3d==0.17.1, pypcd +``` + +Firstly follow the instructions [here](https://github.com/open-mmlab/mmdetection3d/blob/master/docs/en/getting_started.md) to install mmdetection3d. Make sure the version of mmdetection3d is exactly 0.17.1. + +Note that pypcd pip installing is not compatible with Python3. Therefore, [a modified version](https://github.com/dimatura/pypcd) should be manually installed as followings. +```bash +git clone https://github.com/klintan/pypcd.git +cd pypcd +python setup.py install +``` + +b. Download AB3DMOT +``` +git clone https://github.com/xinshuoweng/AB3DMOT.git + +``` +Install AB3DMOT refer to [AB3DMOT Installation](https://github.com/xinshuoweng/AB3DMOT/blob/master/docs/INSTALL.md) + +Note: Please add the path of AB3DMOT and Xinshuo_PyToolbox to your PYTHONPATH, according to the AB3DMOT Installation. + + +c. Download DAIR-V2X +``` +git clone https://github.com/AIR-THU/DAIR-V2X.git + +``` + +### Data Preparation + +#### a.Download data and organize as follows + +Download SPD dataset [here](https://thudair.baai.ac.cn/coop-forecast) and organize as follows: + +``` + +# For SPD Dataset located at ${SPD_DATASET_ROOT} +V2X-Seq-SPD/ + └── infrastructure-side # Infrastructure-side data + ├── image + ├── {id}.jpg + ├── velodyne + ├── {id}.pcd + ├── calib + ├── camera_intrinsic # Camera intrinsic parameter + ├── {id}.json + ├── virtuallidar_to_world # Extrinsic parameter from virtual LiDAR coordinate system to world coordinate system + ├── {id}.json + ├── virtuallidar_to_camera # Extrinsic parameter from virtual LiDAR coordinate system to camera coordinate system + ├── {id}.json + ├── label + ├── camera # Labeles in infrastructure virtual LiDAR coordinate system fitting objects in image with image camptured timestamp + ├── {id}.json + ├── virtuallidar # Labeles in infrastructure virtual LiDAR coordinate system fitting objects in point cloud with point cloud captured timestamp + ├── {id}.json + └── data_info.json # More detailed information for each infrastructure-side frame + └── vehicle-side # Vehicle-side data + ├── image + ├── {id}.jpg + ├── velodyne + ├── {id}.pcd + ├── calib + ├── camera_intrinsic # Camera intrinsic parameter + ├── {id}.json + ├── lidar_to_camera # extrinsic parameter from LiDAR coordinate system to camera coordinate system + ├── {id}.json + ├── lidar_to_novatel # extrinsic parameter from LiDAR coordinate system to NovAtel coordinate system + ├── {id}.json + ├── novatel_to_world # location in the world coordinate system + ├── {id}.json + ├── label + ├── camera # Labeles in vehicle LiDAR coordinate system fitting objects in image with image camptured timestamp + ├── {id}.json + ├── lidar # Labeles in vehicle LiDAR coordinate system fitting objects in point cloud with point cloud captured timestamp + ├── {id}.json + └── data_info.json # More detailed information for each vehicle-side frame + └── cooperative # Coopetative-view files + ├── label # Vehicle-infrastructure cooperative (VIC) annotation files. Labeles in vehicle LiDAR coordinate system with the vehicle point cloud timestamp + ├── {id}.json + └── data_info.json # More detailed information for vehicle-infrastructure cooperative frame pair + └── maps # HD Maps for each intersection + +``` + +#### b.Create a symlink to the dataset root + +``` +cd DAIR-V2X +cd ./data/ +ln -s ${SPD_DATASET_ROOT}/V2X-Seq-SPD +``` +#### c.Convert V2X-Seq-SPD cooperative label to V2X-Seq-SPD-KITTI format (Option for tracking evaluation) +``` +cd DAIR-V2X +python tools/dataset_converter/spd2kitti_tracking/coop_label_dair2kitti.py \ + --source-root ./data/V2X-Seq-SPD \ + --target-root ./data/V2X-Seq-SPD-KITTI/cooperative \ + --split-path ./data/split_datas/cooperative-split-data-spd.json \ + --no-classmerge + +``` +At the end of the process, the data and info files should be organized as follows: + +``` +DAIR-V2X/data/V2X-Seq-SPD-KITTI/ + └──── cooperative + ├──── training + ├──── {sequence_id} + ├──── label_02 + ├───── {sequence_id}.txt + ├──── validation + └──── testing +``` + +### Evaluation Example + +Here we provide an example to evaluate the late fusion results for VIC3D Tracking on the V2X-Seq-SPD dataset for Image. +We use ImvoxelNet to perceive 2D objects from the infrastructure and ego-vehicle sequential images. Next, we transmit the infrastructure objects to the ego vehicle and fuse them with the ego-vehicle objects based on Euclidean distance measurements. Then we use AB3DMOT to track the fused objects. + +#### Detection Checkpoint Preparation +Download checkpoints of ImvoxelNet trained on SPD datasets with mmdetection3d from Google drive: [inf-model](https://drive.google.com/file/d/1XntybUfSXQMZgiZnT7INRYPLBuHXT-Lv/view?usp=sharing) & [veh-model](https://drive.google.com/file/d/1eZWsG3VzMuC8swYfVveM3Zg3fcGR6IvN/view?usp=sharing). + +Put the checkpoints under [this folder](../configs/vic3d-spd/late-fusion-image/imvoxelnet/). +The file structure should be like: + +``` +DAIR-V2X/configs/vic3d-spd/late-fusion-image/imvoxelnet/ + ├──trainval_config_i.py + ├──vic3d_latefusion_imvoxelnet_i.pth + ├──trainval_config_v.py + ├──vic3d_latefusion_imvoxelnet_v.pth +``` + +#### Evaluation + +Run the following commands for evaluation: + +```bash +cd DAIR-V2X +cd v2x +bash scripts/eval_camera_late_fusion_spd.sh 0 0 0 100 --no-comp +``` + +The parameters are: + +- **CUDA_VISIBLE_DEVICES**: GPU IDs +- **DELAY_K**: the number of previous frames for `vic-async-spd` dataset. `vic-async-spd-0` is equivalent to `vic-sync-spd` dataset. +- **EXTEND_RANGE_START**: x_{min} of the interested area of vehicle-egocentric surroundings at Vehicle LiDAR +- **EXTEND_RANGE_END**: x_{max} of the interested area of vehicle-egocentric surroundings at Vehicle LiDAR +- **TIME_COMPENSATION**: for `late_fusion`, you can remove the time compensation module by an addtional argument **--no-comp** + + +If everything is prepared properly, the output results should be: + +``` +car 3d IoU threshold 0.50, Average Precision = 17.31 +car bev IoU threshold 0.50, Average Precision = 22.53 +AMOTA = 0.0622 +AMOTP = 0.2524 + +``` + +#### Reproducing Benchmark Results +We release our benchmarks for detection and tracking tasks with different fusion strategies for Image. Refer to the [README](../configs/vic3d-spd/late-fusion-image/README.md) for implementation details. + +We will soon release the benchmarks for detection and tracking tasks with all modalities, fusion types, and fusion methods for our V2X-Seq-SPD dataset. Please stay tuned! + + +### API usage + +To simply load our V2X-Seq-SPD dataset, please refer to [this](./apis/dataloaders_spd.md). + +To visualize LiDAR or camera frames in V2X-Seq-SPD, please refer to [this](./visualization_spd.md). diff --git a/tools/dataset_converter/README.md b/tools/dataset_converter/README.md new file mode 100644 index 0000000..e8854b8 --- /dev/null +++ b/tools/dataset_converter/README.md @@ -0,0 +1,200 @@ +# Affine transformation of coordinate system + +## Transformation Matrix + +### Rotation Matrix + +Rotate around the x-axis, y-axis and z-axis respectively, and multiply the three rotation matrices to obtain the rotation matrix at any angle in 3D space. (Right-handed coordinate system) + +When rotating around the x-axis, it can be seen as a rotation on the 2D plane of yoz, at which time the value of x remains unchanged. + +$$ +R_x += +\begin{bmatrix} +1& 0&0 +\\ +0&cos\theta_x&sin\theta_x +\\ +0&-sin\theta_x&cos\theta_x +\end{bmatrix} +$$ + +When rotating around the y-axis, it can be seen as a rotation on the 2D plane of zox, at which time the value of y remains unchanged. + +$$ +R_y += +\begin{bmatrix} +cos\theta_y&0&-sin\theta_y +\\ +0&1&0 +\\ +sin\theta_y&0&cos\theta_y +\end{bmatrix} +$$ + +When rotating around the z-axis, it can be seen as a rotation on the 2D plane of xoy, at which time the value of z remains unchanged. + +$$ +R_z += +\begin{bmatrix} +cons\theta_z&sin\theta_z&0 +\\ +-sin\theta_z&cos\theta_z&0 +\\ +0&0&1 +\end{bmatrix} +$$ + +The final 3D rotation matrix is the multiplication of the above three matrices. + +$$ +R=R_xR_yR_z += +\begin{bmatrix} +1&0&0 +\\ +0&cos\theta_x&sin\theta_x +\\ +0&-sin\theta_x&cos\theta_x +\end{bmatrix} +\begin{bmatrix} +cos\theta_y&0&-sin\theta_y +\\ +0&1&0 +\\ +sin\theta_y&0&cos\theta_y +\end{bmatrix} +\begin{bmatrix} +cons\theta_z&sin\theta_z&0 +\\ +-sin\theta_z&cos\theta_z&0 +\\ +0&0&1 +\end{bmatrix} +$$ + +### Translation Matrix + +Translate along the x-axis direction, y-axis direction and z-axis direction respectively, and add the three translation matrices to obtain any translation matrix in 3D space. + +When translating along the x-axis direction, it can be seen that each point is translated along the x-axis direction. At this time, the values of y and z remain unchanged. + +$$ +T_x= +\begin{bmatrix} +\Delta_x +\\ +0 +\\ +0 +\end{bmatrix} +$$ + +When translating along the y-axis direction, it can be seen that each point is translated along the y-axis direction. At this time, the values of z and x remain unchanged. + +$$ +T_y= +\begin{bmatrix} +0 +\\ +\Delta_y +\\ +0 +\end{bmatrix} +$$ + +When translating along the z-axis direction, it can be seen that each point is translated along the z-axis direction. At this time, the values of x and y remain unchanged. + +$$ +T_z= +\begin{bmatrix} +0 +\\ +0 +\\ +\Delta_z +\end{bmatrix} +$$ + +The final 3D translation matrix is the sum of the above three matrices. + +$$ +T= +T_x+T_y+T_z += +\begin{bmatrix} +\Delta_x +\\ +\Delta_y +\\ +\Delta_z +\end{bmatrix} +$$ + +## Related Codes + +### 7 Dimensions Vector Representation to 8 Corner Points Representation + +```Python +def get_lidar_3d_8points(label_3d_dimensions, lidar_3d_location, rotation_z): + """ + 4 -------- 5 + /| /| + 7 -------- 6 . + | | | | + . 0 -------- 1 + |/ |/ + 3 -------- 2 + forward direction: 3 -> 0 + Args: + label_3d_dimensions: [l, w, h] + lidar_3d_location: [x, y, z] + rotation_z: rotation + """ + lidar_rotation = np.matrix( + [ + [math.cos(rotation_z), -math.sin(rotation_z), 0], + [math.sin(rotation_z), math.cos(rotation_z), 0], + [0, 0, 1] + ] + ) + l, w, h = label_3d_dimensions + corners_3d_lidar = np.matrix( + [ + [l / 2, l / 2, -l / 2, -l / 2, l / 2, l / 2, -l / 2, -l / 2], + [w / 2, -w / 2, -w / 2, w / 2, w / 2, -w / 2, -w / 2, w / 2], + [-h / 2, -h / 2, -h / 2, -h / 2, h / 2, h / 2, h / 2, h / 2], + ] + ) + lidar_3d_8points = lidar_rotation * corners_3d_lidar + np.matrix(lidar_3d_location).T + return lidar_3d_8points.T.tolist() +``` + +7 Dimensions Vector [l, w, h, x, y, z, rotation] can be obtained from the json files in the following directory: + +* `data/DAIR-V2X-V2/cooperative-vehicle-infrastructure/infrastructure-side/label/camera/xxxxxx.json` +* `data/DAIR-V2X-V2/cooperative-vehicle-infrastructure/infrastructure-side/label/virtuallidar/xxxxxx.json` +* `data/DAIR-V2X-V2/cooperative-vehicle-infrastructure/vehicle-side/label/camera/xxxxxx.json` +* `data/DAIR-V2X-V2/cooperative-vehicle-infrastructure/vehicle-side/label/lidar/xxxxxx.json` + +### Transform point + +```Python +def trans_point(input_point, translation, rotation): + input_point = np.array(input_point).reshape(3, 1) + translation = np.array(translation).reshape(3, 1) + rotation = np.array(rotation).reshape(3, 3) + output_point = np.dot(rotation, input_point).reshape(3, 1) + np.array(translation).reshape(3, 1) + output_point = output_point.reshape(1, 3).tolist() + return output_point[0] +``` + +Rotation Matrix and Translation Matrix can be obtained from the json files in the following directory: + +* `data/DAIR-V2X-V2/cooperative-vehicle-infrastructure/infrastructure-side/calib/xxxx/xxxxxx.json` +* `data/DAIR-V2X-V2/cooperative-vehicle-infrastructure/vehicle-side/calib/xxxx/xxxxxx.json` + +If you have the rotation matrix and translation matrix from A coordinate system to B coordinate system, you can obtain the rotation matrix and translation matrix from B coordinate system to A coordinate system through the following code: diff --git a/tools/dataset_converter/concatenate_pcd2bin_spd.py b/tools/dataset_converter/concatenate_pcd2bin_spd.py new file mode 100644 index 0000000..997e90c --- /dev/null +++ b/tools/dataset_converter/concatenate_pcd2bin_spd.py @@ -0,0 +1,92 @@ +import numpy as np +from pypcd import pypcd +import os +import errno +import json +from tqdm import tqdm +import argparse + + +def mkdir_p(path): + try: + os.makedirs(path) + except OSError as exc: # Python >2.5 + if exc.errno == errno.EEXIST and os.path.isdir(path): + pass + else: + raise + + +def read_json(path_json): + with open(path_json, "r") as load_f: + my_json = json.load(load_f) + return my_json + + +def concatenate_pcd2bin(path1, path2, path_save): + pc1 = pypcd.PointCloud.from_path(path1) + pc2 = pypcd.PointCloud.from_path(path2) + + np_x1 = (np.array(pc1.pc_data["x"], dtype=np.float32)).astype(np.float32) + np_y1 = (np.array(pc1.pc_data["y"], dtype=np.float32)).astype(np.float32) + np_z1 = (np.array(pc1.pc_data["z"], dtype=np.float32)).astype(np.float32) + np_i1 = (np.array(pc1.pc_data["intensity"], dtype=np.float32)).astype(np.float32) / 255 + + np_x2 = (np.array(pc2.pc_data["x"], dtype=np.float32)).astype(np.float32) + np_y2 = (np.array(pc2.pc_data["y"], dtype=np.float32)).astype(np.float32) + np_z2 = (np.array(pc2.pc_data["z"], dtype=np.float32)).astype(np.float32) + np_i2 = (np.array(pc2.pc_data["intensity"], dtype=np.float32)).astype(np.float32) / 255 + + np_x = np.append(np_x1, np_x2) + np_y = np.append(np_y1, np_y2) + np_z = np.append(np_z1, np_z2) + np_i = np.append(np_i1, np_i2) + + points_32 = np.transpose(np.vstack((np_x, np_y, np_z, np_i))) + points_32.tofile(path_save) + + +def concatenate_pcd_i_and_v(path_c, path_i2v, path_dest): + mkdir_p(path_dest) + + path_c_data_info = os.path.join(path_c, "cooperative/data_info.json") + c_data_info = read_json(path_c_data_info) + + for data in tqdm(c_data_info): + path_pcd_v = os.path.join(path_c, "vehicle-side/velodyne", data["vehicle_frame"] + ".pcd") + + name_i = data["infrastructure_frame"] + ".pcd" + path_pcd_i = os.path.join(path_i2v, name_i) + + name = data["vehicle_frame"] + ".bin" + path_save = os.path.join(path_dest, name) + concatenate_pcd2bin(path_pcd_i, path_pcd_v, path_save) + + +parser = argparse.ArgumentParser("Concat the Converted Infrastructure Point Cloud with Vehicle Point Cloud.") +parser.add_argument( + "--source-root", + type=str, + default="./data/SPD/cooperative-vehicle-infrastructure", + help="Raw data root about SPD-C.", +) +parser.add_argument( + "--i2v-root", + type=str, + default="./data/SPD/cooperative-vehicle-infrastructure/vic3d-early-fusion/velodyne/lidar_i2v", + help="The data root where the data with ego-vehicle coordinate is generated.", +) +parser.add_argument( + "--target-root", + type=str, + default="./data/SPD/cooperative-vehicle-infrastructure/vic3d-early-fusion/velodyne-concated", + help="The concated point cloud.", +) + +if __name__ == "__main__": + args = parser.parse_args() + path_c = args.source_root + path_i2v = args.i2v_root + path_dest = args.target_root + + concatenate_pcd_i_and_v(path_c, path_i2v, path_dest) diff --git a/tools/dataset_converter/gen_vic3d_early_fusion_training_spd.py b/tools/dataset_converter/gen_vic3d_early_fusion_training_spd.py new file mode 100644 index 0000000..8304e14 --- /dev/null +++ b/tools/dataset_converter/gen_vic3d_early_fusion_training_spd.py @@ -0,0 +1,39 @@ +import os +import json +import argparse +from tqdm import tqdm + + +parser = argparse.ArgumentParser("Generate the Early Fusion Data") +parser.add_argument("--source-root", type=str, default="data/V2X-Seq-SPD", help="Raw data root about SPD.") + + +def read_json(path_json): + with open(path_json, "r") as load_f: + my_json = json.load(load_f) + return my_json + + +if __name__ == "__main__": + args = parser.parse_args() + source_root = args.source_root + + os.makedirs(f'{source_root}/vic3d-early-fusion-training/calib/camera_intrinsic', exist_ok=True) + os.makedirs(f'{source_root}/vic3d-early-fusion-training/calib/lidar_to_camera', exist_ok=True) + os.makedirs(f'{source_root}/vic3d-early-fusion-training/calib/lidar_to_novatel', exist_ok=True) + os.makedirs(f'{source_root}/vic3d-early-fusion-training/calib/novatel_to_world', exist_ok=True) + os.makedirs(f'{source_root}/vic3d-early-fusion-training/image', exist_ok=True) + os.makedirs(f'{source_root}/vic3d-early-fusion-training/velodyne', exist_ok=True) + os.makedirs(f'{source_root}/vic3d-early-fusion-training/label/lidar', exist_ok=True) + + coop_data_info = read_json(f"{source_root}/cooperative/data_info.json") + for i in tqdm(coop_data_info): + os.system("cp %s/vehicle-side/calib/camera_intrinsic/%s.json %s/vic3d-early-fusion-training/calib/camera_intrinsic/" % (source_root, i["vehicle_frame"], source_root)) + os.system("cp %s/vehicle-side/calib/lidar_to_camera/%s.json %s/vic3d-early-fusion-training/calib/lidar_to_camera/" % (source_root, i["vehicle_frame"], source_root)) + os.system("cp %s/vehicle-side/calib/lidar_to_novatel/%s.json %s/vic3d-early-fusion-training/calib/lidar_to_novatel/" % (source_root, i["vehicle_frame"], source_root)) + os.system("cp %s/vehicle-side/calib/novatel_to_world/%s.json %s/vic3d-early-fusion-training/calib/novatel_to_world/" % (source_root, i["vehicle_frame"], source_root)) + + os.system("cp %s/vehicle-side/image/%s.jpg %s/vic3d-early-fusion-training/image/" % (source_root, i["vehicle_frame"], source_root)) + os.system("cp %s/cooperative/label/%s.json %s/vic3d-early-fusion-training/label/lidar/" % (source_root, i["vehicle_frame"], source_root)) + + os.system("cp %s/vehicle-side/data_info.json %s/vic3d-early-fusion-training/" % (source_root, source_root)) diff --git a/tools/dataset_converter/get_fusion_data_info_spd.py b/tools/dataset_converter/get_fusion_data_info_spd.py new file mode 100644 index 0000000..58131cf --- /dev/null +++ b/tools/dataset_converter/get_fusion_data_info_spd.py @@ -0,0 +1,79 @@ +import os +import json +from tqdm import tqdm +import argparse +import errno + + +def read_json(path_json): + with open(path_json, "r") as load_f: + my_json = json.load(load_f) + return my_json + + +def write_json(path_json, new_dict): + with open(path_json, "w") as f: + json.dump(new_dict, f) + + +def mkdir_p(path): + try: + os.makedirs(path) + except OSError as exc: # Python >2.5 + if exc.errno == errno.EEXIST and os.path.isdir(path): + pass + else: + raise + + +def get_data(data_info, frame_id): + for data in data_info: + if data["frame_id"] == frame_id: + return data + + +def choose_name(name_list, path_v_data_info): + v_data_info = read_json(path_v_data_info) + fusion_data_info = [] + for i in tqdm(range(len(name_list))): + data = get_data(v_data_info, name_list[i]) + fusion_data_info.append(data) + return fusion_data_info + + +def get_name(path_c_data_info): + c_data_info = read_json(path_c_data_info) + name_list = [] + for data in c_data_info: + name = data["vehicle_frame"] + name_list.append(name) + return name_list + + +def get_fusion_label(path_c, path_dest): + path_c_data_info = os.path.join(path_c, "cooperative/data_info.json") + path_v_data_info = os.path.join(path_c, "vehicle-side/data_info.json") + name_list = get_name(path_c_data_info) + fusion_data_info = choose_name(name_list, path_v_data_info) + write_json(os.path.join(path_dest, "fusion_data_info.json"), fusion_data_info) + + +parser = argparse.ArgumentParser("Generate cooperative-vehicle data info.") +parser.add_argument( + "--source-root", + type=str, + default="./data/SPD/cooperative-vehicle-infrastructure", + help="Raw data root about SPD.", +) +parser.add_argument( + "--target-root", + type=str, + default="./data_info-fusioned", + help="The fusioned data info", +) + +if __name__ == "__main__": + args = parser.parse_args() + source_root = args.source_root + target_label_root = args.target_root + get_fusion_label(source_root, target_label_root) diff --git a/tools/dataset_converter/label_det_result2kitti.py b/tools/dataset_converter/label_det_result2kitti.py new file mode 100644 index 0000000..0a4d041 --- /dev/null +++ b/tools/dataset_converter/label_det_result2kitti.py @@ -0,0 +1,230 @@ +import os +import math +import pickle +import numpy as np +from tqdm import tqdm +#from tools.dataset_converter.utils import read_json, trans_point, get_lidar2camera, get_cam_calib_intrinsic, get_label_lidar_rotation, get_camera_3d_alpha_rotation +from utils import read_json, trans_point, get_lidar2camera, get_cam_calib_intrinsic, get_label_lidar_rotation, get_camera_3d_alpha_rotation +import argparse + +type2id = { + "Car": 2, + "Van": 2, + "Truck": 2, + "Bus": 2, + "Cyclist": 1, + "Tricyclist": 3, + "Motorcyclist": 3, + "Barrow": 3, + "Barrowlist": 3, + "Pedestrian": 0, + "Trafficcone": 3, + "Pedestrianignore": 3, + "Carignore": 3, + "otherignore": 3, + "unknowns_unmovable": 3, + "unknowns_movable": 3, + "unknown_unmovable": 3, + "unknown_movable": 3, +} + +id2type = { + 0: "Pedestrian", + 1: "Cyclist", + 2: "Car", + 3: "Motorcyclist" +} + + +def get_sequence_id(frame, data_info): + for obj in data_info: + if frame == obj["frame_id"]: + sequence_id = obj["sequence_id"] + return sequence_id + + +def trans_points_cam2img(camera_3d_8points, calib_intrinsic, with_depth=False): + """ + Transform points from camera coordinates to image coordinates. + Args: + camera_3d_8points: list(8, 3) + calib_intrinsic: np.array(3, 4) + Returns: + list(8, 2) + """ + camera_3d_8points = np.array(camera_3d_8points) + points_shape = np.array([8, 1]) + points_4 = np.concatenate((camera_3d_8points, np.ones(points_shape)), axis=-1) + point_2d = np.dot(calib_intrinsic, points_4.T) + point_2d = point_2d.T + point_2d_res = point_2d[:, :2] / point_2d[:, 2:3] + if with_depth: + return np.cat([point_2d_res, point_2d[..., 2:3]], dim=-1) + return point_2d_res.tolist() + + +def label_det_result2kitti(input_file_path, output_dir_path, spd_path): + """ + Convert detection results from mmdetection3d_kitti format to KITTI format. + Args: + input_file_path: mmdetection3d_kitti results pickle file path + output_dir_path: converted kitti format file directory + spd_path: path to SPD dataset + """ + if not os.path.exists(output_dir_path): + os.makedirs(output_dir_path) + with open(input_file_path, 'rb') as load_f: + det_result_data = pickle.load(load_f) + + veh_frame = det_result_data["veh_id"] + lidar2camera_path = f'{spd_path}/vehicle-side/calib/lidar_to_camera/{veh_frame}.json' + camera2image_path = f'{spd_path}/vehicle-side/calib/camera_intrinsic/{veh_frame}.json' + rotation, translation = get_lidar2camera(lidar2camera_path) + calib_intrinsic = get_cam_calib_intrinsic(camera2image_path) + output_file_path = output_dir_path + '/' + veh_frame + '.txt' + if os.path.exists(output_file_path): + print("veh_frame", veh_frame, "det_result_name", input_file_path.split('/')[-1].split('.')[0]) + save_file = open(output_file_path, 'a') + else: + save_file = open(output_file_path, 'w') + num_boxes = len(det_result_data["labels_3d"].tolist()) + for i in range(num_boxes): + lidar_3d_8points_det_result = det_result_data["boxes_3d"][i].tolist() + lidar_3d_8points = [lidar_3d_8points_det_result[3], lidar_3d_8points_det_result[0], lidar_3d_8points_det_result[4], + lidar_3d_8points_det_result[7], lidar_3d_8points_det_result[2], lidar_3d_8points_det_result[1], + lidar_3d_8points_det_result[5], lidar_3d_8points_det_result[6]] + + # calculate l, w, h, x, y, z in LiDAR coordinate system + lidar_xy0, lidar_xy3, lidar_xy1 = lidar_3d_8points[0][0:2], lidar_3d_8points[3][0:2], lidar_3d_8points[1][0:2] + lidar_z4, lidar_z0 = lidar_3d_8points[4][2], lidar_3d_8points[0][2] + l = math.sqrt((lidar_xy0[0] - lidar_xy3[0]) ** 2 + (lidar_xy0[1] - lidar_xy3[1]) ** 2) + w = math.sqrt((lidar_xy0[0] - lidar_xy1[0]) ** 2 + (lidar_xy0[1] - lidar_xy1[1]) ** 2) + h = lidar_z4 - lidar_z0 + lidar_x0, lidar_y0 = lidar_3d_8points[0][0], lidar_3d_8points[0][1] + lidar_x2, lidar_y2 = lidar_3d_8points[2][0], lidar_3d_8points[2][1] + lidar_x = (lidar_x0 + lidar_x2) / 2 + lidar_y = (lidar_y0 + lidar_y2) / 2 + lidar_z = (lidar_z0 + lidar_z4) / 2 + + obj_type = id2type[det_result_data["labels_3d"][i]] + score = det_result_data["scores_3d"][i] + + camera_3d_8points = [] + for lidar_point in lidar_3d_8points: + camera_point = trans_point(lidar_point, rotation, translation) + camera_3d_8points.append(camera_point) + + # generate the yaw angle of the object in the lidar coordinate system at the vehicle-side. + lidar_rotation = get_label_lidar_rotation(lidar_3d_8points) + # generate the alpha and yaw angle of the object in the camera coordinate system at the vehicle-side + camera_x0, camera_z0 = camera_3d_8points[0][0], camera_3d_8points[0][2] + camera_x2, camera_z2 = camera_3d_8points[2][0], camera_3d_8points[2][2] + camera_x = (camera_x0 + camera_x2) / 2 + camera_y = camera_3d_8points[0][1] + camera_z = (camera_z0 + camera_z2) / 2 + camera_3d_location = [camera_x, camera_y, camera_z] + + image_8points_2d = trans_points_cam2img(camera_3d_8points, calib_intrinsic) + x_max = max(image_8points_2d[:][0]) + x_min = min(image_8points_2d[:][0]) + y_max = max(image_8points_2d[:][1]) + y_min = min(image_8points_2d[:][1]) + + alpha, camera_rotation = get_camera_3d_alpha_rotation(camera_3d_8points, camera_3d_location) + + str_item = str(veh_frame) + ' ' + str(obj_type) + ' ' + '-1' + ' ' + '-1' + ' ' + '-1' + ' ' + str(alpha) + ' ' + str( + x_min) + ' ' + str(y_min) + ' ' + str(x_max) + ' ' + str(y_max) + ' ' + str(h) + ' ' + str(w) + ' ' + str(l) + ' ' + str( + camera_x) + ' ' + str(camera_y) + ' ' + str(camera_z) + ' ' + str(camera_rotation) + ' ' + str(lidar_x) + ' ' + str( + lidar_y) + ' ' + str(lidar_z) + ' ' + str(lidar_rotation) + ' ' + '-1' + ' ' + str(score) + ' ' + '-1' + ' ' + '-1' + '\n' + save_file.writelines(str_item) + save_file.close() + + +def gen_kitti_result(input_dir_path, output_dir_path, spd_path): + """ + Convert detection results from mmdetection3d_kitti format to KITTI format for all files in input_dir_path. + Args: + input_dir_path: directory containing mmdetection3d_kitti results pickle files + output_dir_path: directory to save converted KITTI format files + spd_path: path to SPD dataset + """ + if os.path.exists(output_dir_path): + os.system('rm -rf %s' % output_dir_path) + os.makedirs(output_dir_path) + for file in tqdm(os.listdir(input_dir_path)): + path_file = input_dir_path + '/' + file + label_det_result2kitti(path_file, output_dir_path, spd_path) + + +def gen_kitti_seq_result(input_dir_path, output_dir_path, spd_path): + """ + Convert detection results from mmdetection3d_kitti format to KITTI format and group them by sequence. + Args: + input_dir_path: directory containing mmdetection3d_kitti results pickle files + output_dir_path: directory to save converted KITTI format files grouped by sequence + spd_path: path to SPD dataset + """ + data_info = read_json(f'{spd_path}/vehicle-side/data_info.json') + list_input_files = os.listdir(input_dir_path) + if os.path.exists(output_dir_path): + os.system('rm -rf %s' % output_dir_path) + os.makedirs(output_dir_path) + for input_file in tqdm(list_input_files): + input_file_path = input_dir_path + '/' + input_file + sequence_id = get_sequence_id(input_file.split('.')[0], data_info) + sequence_path = output_dir_path + '/' + sequence_id + if not os.path.exists(sequence_path): + os.makedirs(sequence_path) + os.system('cp %s %s/' % (input_file_path, sequence_path)) + + +def gen_kitti_seq_txt(input_dir_path, output_dir_path): + """ + Group converted KITTI format files by sequence and write them into one txt file per sequence. + Args: + input_dir_path: directory containing KITTI format files grouped by sequence + output_dir_path: directory to save txt files grouped by sequence + """ + if os.path.exists(output_dir_path): + os.system('rm -rf %s' % output_dir_path) + os.makedirs(output_dir_path) + list_dir_sequences = os.listdir(input_dir_path) + for dir_sequence in tqdm(list_dir_sequences): + path_seq_input = input_dir_path + '/' + dir_sequence + file_output = output_dir_path + '/' + dir_sequence + '.txt' + save_file = open(file_output, 'w') + list_files = os.listdir(path_seq_input) + list_files.sort() + for file in list_files: + path_file = path_seq_input + '/' + file + with open(path_file, "r") as read_f: + data_txt = read_f.readlines() + for item in data_txt: + save_file.writelines(item) + save_file.close() + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description='Convert detection results to KITTI format') + parser.add_argument('--input-dir-path', type=str, required=True, help='Directory containing mmdetection3d_kitti results pickle files') + parser.add_argument('--output-dir-path', type=str, required=True, help='Directory to save converted KITTI format files') + parser.add_argument('--spd-path', type=str, required=True, help='Path to SPD dataset') + args = parser.parse_args() + + input_dir_path = args.input_dir_path + spd_path = args.spd_path + + output_dir_path = os.path.join(args.output_dir_path, 'label') + output_dir_path_seq = os.path.join(args.output_dir_path, 'label_seq') + output_dir_path_track = os.path.join(args.output_dir_path + 'label_track') + # Convert detection results from mmdetection3d_kitti format to KITTI format for all files in input_dir_path + gen_kitti_result(input_dir_path, output_dir_path, spd_path) + # Group converted KITTI format files by sequence + gen_kitti_seq_result(output_dir_path, output_dir_path_seq, spd_path) + # Group converted KITTI format files by sequence and write them into one txt file per sequence + gen_kitti_seq_txt(output_dir_path_seq, output_dir_path_track) + + os.system("cp %s/* %s/"%(output_dir_path_track,args.output_dir_path)) + os.system("rm -rf %s"%(output_dir_path)) + os.system("rm -rf %s"%(output_dir_path_seq)) + os.system("rm -rf %s"%(output_dir_path_track)) diff --git a/tools/dataset_converter/label_i2v.py b/tools/dataset_converter/label_i2v.py new file mode 100644 index 0000000..8e8518a --- /dev/null +++ b/tools/dataset_converter/label_i2v.py @@ -0,0 +1,254 @@ +import os +import argparse +import numpy as np +from rich.progress import track +from tools.dataset_converter.utils import read_json, write_json, inverse_matrix, trans_point, get_lidar_3d_8points, get_label_lidar_rotation, \ + get_camera_3d_alpha_rotation, get_cam_calib_intrinsic, get_lidar2camera, get_lidar2novatel, get_novatel2world, get_virtuallidar2world + + +def concat_txt(path_input, path_output, file_name_output): + if not os.path.exists(path_output): + os.makedirs(path_output) + path_file_output = path_output + '/' + file_name_output + '.txt' + write_f = open(path_file_output, 'w') + list_files = os.listdir(path_input) + list_files.sort() + for file in list_files: + path_file_input = path_input + '/' + file + with open(path_file_input, 'r') as read_f: + list_lines = read_f.readlines() + for line in list_lines: + write_f.writelines(line) + write_f.close() + + +def concat_kitti_label_txt(path_input): + """ + Args: + path_input: "../../data/KITTI/cooperative-vehicle-infrastructure/" + vi + "/" + tvt + Returns: + None + """ + list_sequence = os.listdir(path_input) + list_sequence.sort() + for sequence in track(list_sequence): + path_input_label = path_input + '/' + sequence + '/label_02_i2v_split' + path_output_label = path_input + '/' + sequence + '/label_02_i2v' + concat_txt(path_input_label, path_output_label, sequence) + + +def gen_label_track_i2v(kitti_target_root): + for tvt in ["training", "validation", "testing"]: + input_path = kitti_target_root + '/' + tvt + concat_kitti_label_txt(input_path) + + +def get_frame_data_info(data_info, frame_id): + for data in data_info: + if data["frame_id"] == frame_id: + return data + + +def trans_points_cam2img(camera_3d_8_points, calib_intrinsic, with_depth=False): + """ + Project points from camera coordicates to image coordinates. + Args: + camera_3d_8_points: list(8, 3) + calib_intrinsic: np.array(3, 4) + Returns: + list(8, 2) + """ + camera_3d_8_points = np.array(camera_3d_8_points) + points_shape = np.array([8, 1]) + points_4 = np.concatenate((camera_3d_8_points, np.ones(points_shape)), axis=-1) + point_2d = np.dot(calib_intrinsic, points_4.T) + point_2d = point_2d.T + point_2d_res = point_2d[:, :2] / point_2d[:, 2:3] + if with_depth: + return np.cat([point_2d_res, point_2d[..., 2:3]], dim=-1) + return point_2d_res.tolist() + + +def trans_point_i2v(input_point, path_virtuallidar2world, path_novatel2world, path_lidar2novatel, delta_x, delta_y): + # virtuallidar to world + rotation, translation = get_virtuallidar2world(path_virtuallidar2world) + point = trans_point(input_point, translation, rotation) + + # world to novatel + rotation, translation = get_novatel2world(path_novatel2world) + new_rotation = inverse_matrix(rotation) + new_translation = - np.dot(new_rotation, translation) + point = trans_point(point, new_translation, new_rotation) + + # novatel to lidar + rotation, translation = get_lidar2novatel(path_lidar2novatel) + new_rotation = inverse_matrix(rotation) + new_translation = - np.dot(new_rotation, translation) + point = trans_point(point, new_translation, new_rotation) + + point = np.array(point).reshape(3, 1) + np.array([delta_x, delta_y, 0]).reshape(3, 1) + point = point.reshape(1, 3).tolist()[0] + + return point + + +def trans_label_i2v(dair_inf_label_path, dair_target_label_file, kitti_target_label_file, virtuallidar2world_path, + novatel2world_path, lidar2novatel_path, lidar2camera_path, camera2image_path, delta_x, delta_y, + pointcloud_timestamp): + dair_inf_label_data = read_json(dair_inf_label_path) + r_lidar2camera, t_lidar2camera = get_lidar2camera(lidar2camera_path) + calib_intrinsic = get_cam_calib_intrinsic(camera2image_path) + save_file = open(kitti_target_label_file, 'w') + frame = kitti_target_label_file.split('/')[-1].split('.')[0] + for m in range(len(dair_inf_label_data)): + # 提取每个目标的信息 + i_label_3d_dimensions = [float(dair_inf_label_data[m]["3d_dimensions"]["l"]), + float(dair_inf_label_data[m]["3d_dimensions"]["w"]), + float(dair_inf_label_data[m]["3d_dimensions"]["h"])] + i_label_lidar_3d_location = [float(dair_inf_label_data[m]["3d_location"]["x"]), + float(dair_inf_label_data[m]["3d_location"]["y"]), + float(dair_inf_label_data[m]["3d_location"]["z"])] + i_label_lidar_rotation = dair_inf_label_data[m]["rotation"] + + # 生成车端lidar和camera坐标系下目标的中心点坐标v_label_lidar_3d_location, v_label_camera_3d_location + v_label_lidar_3d_location = trans_point_i2v(i_label_lidar_3d_location, virtuallidar2world_path, novatel2world_path, + lidar2novatel_path, delta_x, delta_y) + v_label_camera_3d_location = trans_point(v_label_lidar_3d_location, t_lidar2camera, r_lidar2camera) + v_label_camera_3d_location[1] = v_label_camera_3d_location[1] + float(dair_inf_label_data[m]["3d_dimensions"]["h"]) / 2 + + # 生成车端坐标系下目标的8个角点坐标 + list_i_lidar_3d_8_points = get_lidar_3d_8points(i_label_3d_dimensions, i_label_lidar_3d_location, i_label_lidar_rotation) + list_v_lidar_3d_8_points = [] + list_v_camera_3d_8_points = [] + for i_lidar_point in list_i_lidar_3d_8_points: + # 投影到车端lidar坐标系 + v_lidar_point = trans_point_i2v(i_lidar_point, virtuallidar2world_path, novatel2world_path, lidar2novatel_path, + delta_x, delta_y) + list_v_lidar_3d_8_points.append(v_lidar_point) + # 投影到车端camera坐标系 + v_camera_point = trans_point(v_lidar_point, t_lidar2camera, r_lidar2camera) + list_v_camera_3d_8_points.append(v_camera_point) + + # 生成车端lidar坐标系下目标的偏航角v_label_lidar_rotation + v_label_lidar_rotation = get_label_lidar_rotation(list_v_lidar_3d_8_points) + # 生成车端lidar坐标系下目标的alpha和偏航角rotation_y + alpha, i_label_camera_rotation = get_camera_3d_alpha_rotation(list_v_camera_3d_8_points, v_label_camera_3d_location) + + # 投影到车端图像坐标系 + v_label_image_8_points_2d = trans_points_cam2img(list_v_camera_3d_8_points, calib_intrinsic) + x_max = max(v_label_image_8_points_2d[:][0]) + x_min = min(v_label_image_8_points_2d[:][0]) + y_max = max(v_label_image_8_points_2d[:][1]) + y_min = min(v_label_image_8_points_2d[:][1]) + + # 更新路端投影到车端的目标信息 + dair_inf_label_data[m]["alpha"] = alpha + dair_inf_label_data[m]["3d_location"]["x"] = v_label_lidar_3d_location[0] + dair_inf_label_data[m]["3d_location"]["y"] = v_label_lidar_3d_location[1] + dair_inf_label_data[m]["3d_location"]["z"] = v_label_lidar_3d_location[2] + dair_inf_label_data[m]["rotation"] = v_label_lidar_rotation + + # 更新贴合camera的label的image 2d信息 + dair_inf_label_data[m]["2d_box"]["xmin"] = x_min + dair_inf_label_data[m]["2d_box"]["ymin"] = y_min + dair_inf_label_data[m]["2d_box"]["xmax"] = x_max + dair_inf_label_data[m]["2d_box"]["ymax"] = y_max + # 保存车端label投影到路端的label文件 + + # 生成 kitti label + list_kitti_label = [frame, dair_inf_label_data[m]["type"], str(dair_inf_label_data[m]["track_id"]), + str(dair_inf_label_data[m]["truncated_state"]), + str(dair_inf_label_data[m]["occluded_state"]), str(dair_inf_label_data[m]["alpha"]), + str(dair_inf_label_data[m]["2d_box"]["xmin"]), + str(dair_inf_label_data[m]["2d_box"]["ymin"]), str(dair_inf_label_data[m]["2d_box"]["xmax"]), + str(dair_inf_label_data[m]["2d_box"]["ymax"]), str(dair_inf_label_data[m]["3d_dimensions"]["h"]), + str(dair_inf_label_data[m]["3d_dimensions"]["w"]), str(dair_inf_label_data[m]["3d_dimensions"]["l"]), + str(v_label_camera_3d_location[0]), str(v_label_camera_3d_location[1]), + str(v_label_camera_3d_location[2]), + str(i_label_camera_rotation), str(dair_inf_label_data[m]["3d_location"]["x"]), + str(dair_inf_label_data[m]["3d_location"]["y"]), str(dair_inf_label_data[m]["3d_location"]["z"]), + str(dair_inf_label_data[m]["rotation"]), pointcloud_timestamp, "1", "1", dair_inf_label_data[m]["token"] + '\n'] + str_kitti_label = ' '.join(list_kitti_label) + save_file.writelines(str_kitti_label) + write_json(dair_target_label_file, dair_inf_label_data) + save_file.close() + + +def get_i2v(dair_source_path, dair_target_path, kitti_target_path, split_info, label_type): + dict_sequence2tvt = {} + for tvt in [["train", "training"], ["val", "validation"], ["test", "testing"]]: + for seq in split_info["batch_split"][tvt[0]]: + dict_sequence2tvt[seq] = tvt[1] + + inf_label_type = label_type.replace("lidar", "virtuallidar") + dair_target_label_path = f'{dair_target_path}/label_i2v/{inf_label_type}' + if not os.path.exists(dair_target_label_path): + os.makedirs(dair_target_label_path) + + coop_data_info_path = f'{dair_source_path}/cooperative/data_info.json' + coop_data_info = read_json(coop_data_info_path) + inf_data_info_path = f'{dair_source_path}/infrastructure-side/data_info.json' + inf_data_info = read_json(inf_data_info_path) + + for i in track(coop_data_info): + + virtuallidar2world_path = f'{dair_source_path}/infrastructure-side/calib/virtuallidar_to_world/{i["infrastructure_frame"]}.json' + novatel2world_path = f'{dair_source_path}/vehicle-side/calib/novatel_to_world/{i["vehicle_frame"]}.json' + lidar2novatel_path = f'{dair_source_path}/vehicle-side/calib/lidar_to_novatel/{i["vehicle_frame"]}.json' + lidar2camera_path = f'{dair_source_path}/vehicle-side/calib/lidar_to_camera/{i["vehicle_frame"]}.json' + camera2image_path = f'{dair_source_path}/vehicle-side/calib/camera_intrinsic/{i["vehicle_frame"]}.json' + delta_x = i["system_error_offset"]["delta_x"] + delta_y = i["system_error_offset"]["delta_y"] + + # 转换label文件 + dair_inf_label_path = f'{dair_source_path}/infrastructure-side/label/{inf_label_type}/{i["infrastructure_frame"]}.json' + dair_target_label_file = f'{dair_target_label_path}/{i["vehicle_frame"]}.json' + kitti_target_label_path = f'{kitti_target_path}/{dict_sequence2tvt[i["infrastructure_sequence"]]}/{i["infrastructure_sequence"]}/label_02_i2v_split' + if not os.path.exists(kitti_target_label_path): + os.makedirs(kitti_target_label_path) + kitti_target_label_file = f'{kitti_target_label_path}/{i["infrastructure_frame"]}.txt' + for j in inf_data_info: + if j["frame_id"] == i["infrastructure_frame"]: + pointcloud_timestamp = j["pointcloud_timestamp"] + trans_label_i2v(dair_inf_label_path, dair_target_label_file, kitti_target_label_file, virtuallidar2world_path, + novatel2world_path, lidar2novatel_path, lidar2camera_path, camera2image_path, delta_x, delta_y, + pointcloud_timestamp) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser("Convert The Label from Infrastructure-side to Vehicle-side") + parser.add_argument( + "--dair-source-root", + type=str, + default="../../data/SPD/cooperative-vehicle-infrastructure", + help="Raw data root about DAIR-V2X-C" + ) + parser.add_argument( + "--dair-target-root", + type=str, + default="../../data/SPD/cooperative-vehicle-infrastructure/infrastructure-side", + help="The dair format infrastructure-side data root", + ) + parser.add_argument( + "--kitti-target-root", + type=str, + default="../../data/KITTI/cooperative-vehicle-infrastructure/infrastructure-side", + help="The kitti format infrastructure-side data root", + ) + parser.add_argument( + "--split-path", + type=str, + default="../../data/split_datas/cooperative-split-data-spd.json", + help="Json file to split the data into training/validation/testing." + ) + parser.add_argument("--label-type", type=str, default="lidar", help="label type from ['lidar', 'camera']") + args = parser.parse_args() + dair_source_root = args.dair_source_root + dair_target_root = args.dair_target_root + kitti_target_root = args.kitti_target_root + split_path = args.split_path + split_info = read_json(split_path) + label_type = args.label_type + + get_i2v(dair_source_root, dair_target_root, kitti_target_root, split_info, label_type) + gen_label_track_i2v(kitti_target_root) diff --git a/tools/dataset_converter/point_cloud_i2v_spd.py b/tools/dataset_converter/point_cloud_i2v_spd.py new file mode 100644 index 0000000..74e3a18 --- /dev/null +++ b/tools/dataset_converter/point_cloud_i2v_spd.py @@ -0,0 +1,177 @@ +import os +import json +import argparse +import numpy as np +from pypcd import pypcd +import open3d as o3d +from tqdm import tqdm +import errno + + +def read_json(path_json): + with open(path_json, 'r') as load_f: + my_json = json.load(load_f) + return my_json + + +def mkdir_p(path): + try: + os.makedirs(path) + except OSError as exc: # Python >2.5 + if exc.errno == errno.EEXIST and os.path.isdir(path): + pass + else: + raise + + +def get_virtuallidar2world(path_virtuallidar2world): + virtuallidar2world = read_json(path_virtuallidar2world) + rotation = virtuallidar2world['rotation'] + translation = virtuallidar2world['translation'] + return rotation, translation + + +def get_novatel2world(path_novatel2world): + novatel2world = read_json(path_novatel2world) + rotation = novatel2world['rotation'] + translation = novatel2world['translation'] + return rotation, translation + + +def get_lidar2novatel(path_lidar2novatel): + lidar2novatel = read_json(path_lidar2novatel) + rotation = lidar2novatel['transform']['rotation'] + translation = lidar2novatel['transform']['translation'] + return rotation, translation + + +def get_data(data_info, frame_id): + for data in data_info: + if data["frame_id"] == frame_id: + return data + + +def trans(input_point, translation, rotation): + input_point = np.array(input_point).reshape(3, -1) + translation = np.array(translation).reshape(3, 1) + rotation = np.array(rotation).reshape(3, 3) + output_point = np.dot(rotation, input_point).reshape(3, -1) + np.array(translation).reshape(3, 1) + return output_point + + +def rev_matrix(R): + R = np.matrix(R) + rev_R = R.I + rev_R = np.array(rev_R) + return rev_R + + +def trans_point_i2v(input_point, path_virtuallidar2world, path_novatel2world, path_lidar2novatel, delta_x, delta_y): + # print('0:', input_point) + + # virtuallidar to world + rotation, translation = get_virtuallidar2world(path_virtuallidar2world) + point = trans(input_point, translation, rotation) + ''' + print('rotation, translation, delta_x, delta_y', rotation, translation, delta_x, delta_y) + print('1:', point) + ''' + + # world to novatel + rotation, translation = get_novatel2world(path_novatel2world) + new_rotation = rev_matrix(rotation) + new_translation = - np.dot(new_rotation, translation) + point = trans(point, new_translation, new_rotation) + ''' + print('rotation, translation:', rotation, translation) + print('new_translation, new_rotation:', new_translation, new_rotation) + print('2:', point) + ''' + + # novatel to lidar + rotation, translation = get_lidar2novatel(path_lidar2novatel) + new_rotation = rev_matrix(rotation) + new_translation = - np.dot(new_rotation, translation) + point = trans(point, new_translation, new_rotation) + np.array([delta_x, delta_y, 0]).reshape(3, 1) + ''' + print('rotation, translation:', rotation, translation) + print('new_translation, new_rotation:', new_translation, new_rotation) + print('3:', point) + ''' + # point = point.reshape(1, 3).tolist() + # point = point[0] + point = point.T + + return point + + +def read_pcd(path_pcd): + pointpillar = o3d.io.read_point_cloud(path_pcd) + points = np.asarray(pointpillar.points) + # points = points.tolist() + return points + + +def show_pcd(path_pcd): + pcd = read_pcd(path_pcd) + o3d.visualization.draw_geometries([pcd]) + + +def write_pcd(path_pcd, new_points, path_save): + pc = pypcd.PointCloud.from_path(path_pcd) + pc.pc_data['x'] = np.array([a[0] for a in new_points]) + pc.pc_data['y'] = np.array([a[1] for a in new_points]) + pc.pc_data['z'] = np.array([a[2] for a in new_points]) + pc.save_pcd(path_save, compression='binary_compressed') + + +def trans_pcd_i2v(path_pcd, path_virtuallidar2world, path_novatel2world, path_lidar2novatel, delta_x, delta_y, path_save): + # (n, 3) + points = read_pcd(path_pcd) + # (n, 3) + new_points = trans_point_i2v(points.T, path_virtuallidar2world, path_novatel2world, path_lidar2novatel, delta_x, delta_y) + write_pcd(path_pcd, new_points, path_save) + + +def get_i2v(path_c, path_dest): + mkdir_p(path_dest) + path_c_data_info = os.path.join(path_c, 'cooperative/data_info.json') + path_i_data_info = os.path.join(path_c, 'infrastructure-side/data_info.json') + path_v_data_info = os.path.join(path_c, 'vehicle-side/data_info.json') + c_data_info = read_json(path_c_data_info) + i_data_info = read_json(path_i_data_info) + v_data_info = read_json(path_v_data_info) + + # for data in tqdm(c_data_info): + for data in tqdm(c_data_info): + i_data = get_data(i_data_info, data["infrastructure_frame"]) + v_data = get_data(v_data_info, data["vehicle_frame"]) + path_pcd_i = os.path.join(path_c, "infrastructure-side/velodyne", data["infrastructure_frame"] + ".pcd") + path_virtuallidar2world = os.path.join(path_c, 'infrastructure-side', i_data['calib_virtuallidar_to_world_path']) + path_novatel2world = os.path.join(path_c, 'vehicle-side', v_data['calib_novatel_to_world_path']) + path_lidar2novatel = os.path.join(path_c, 'vehicle-side', v_data['calib_lidar_to_novatel_path']) + name = os.path.split(path_pcd_i)[-1] + path_save = os.path.join(path_dest, name) + delta_x = data["system_error_offset"]["delta_x"] + delta_y = data["system_error_offset"]["delta_y"] + trans_pcd_i2v(path_pcd_i, path_virtuallidar2world, path_novatel2world, path_lidar2novatel, delta_x, delta_y, path_save) + + +parser = argparse.ArgumentParser("Convert The Point Cloud from Infrastructure to Ego-vehicle") +parser.add_argument("--source-root", + type=str, + default="./data/SPD", + help="Raw data root about SPD.") +parser.add_argument( + "--target-root", + type=str, + default="./data/SPD/vic3d-early-fusion/velodyne/lidar_i2v", + help="The data root where the data with ego-vehicle coordinate is generated", +) + +if __name__ == "__main__": + args = parser.parse_args() + source_root = args.source_root + target_root = args.target_root + + get_i2v(source_root, target_root) \ No newline at end of file diff --git a/tools/dataset_converter/spd2kitti_detection/README.md b/tools/dataset_converter/spd2kitti_detection/README.md new file mode 100644 index 0000000..6c9e1b0 --- /dev/null +++ b/tools/dataset_converter/spd2kitti_detection/README.md @@ -0,0 +1,31 @@ +# Convert SPD to KITTI format + +## Install pypcd + +```bash +git clone https://github.com/klintan/pypcd.git +cd pypcd/ +python setup.py install +``` + +## SPD -> KITTI + +```bash +python tools/dataset_converter/dair2kitti.py \ +--source-root data/SPD/cooperative-vehicle-infrastructure/vehicle-side \ +--target-root data/KITTI/cooperative-vehicle-infrastructure/vehicle-side \ +--split-path data/split_datas/cooperative-split-data-spd.json \ +--label-type lidar \ +--sensor-view vehicle \ +--no-classmerge +``` + +````bash +python tools/dataset_converter/dair2kitti.py \ +--source-root data/SPD/cooperative-vehicle-infrastructure/infrastructure-side \ +--target-root data/KITTI/cooperative-vehicle-infrastructure/infrastructure-side \ +--split-path data/split_datas/cooperative-split-data-spd.json \ +--label-type lidar \ +--sensor-view infrastructure \ +--no-classmerge +```` diff --git a/tools/dataset_converter/spd2kitti_detection/dair2kitti.py b/tools/dataset_converter/spd2kitti_detection/dair2kitti.py new file mode 100644 index 0000000..525e20b --- /dev/null +++ b/tools/dataset_converter/spd2kitti_detection/dair2kitti.py @@ -0,0 +1,75 @@ +import argparse +import os +from tools.dataset_converter.spd2kitti_detection.gen_kitti.label_dair2kitti import label_dair2kitti +from tools.dataset_converter.spd2kitti_detection.gen_kitti.calib_dair2kitti import gen_calib2kitti +from tools.dataset_converter.spd2kitti_detection.gen_kitti.gen_ImageSets_from_split_data import gen_ImageSet +from tools.dataset_converter.utils import read_json, pcd2bin +from rich.progress import track + +parser = argparse.ArgumentParser("Generate the Kitti Format Data") +parser.add_argument("--source-root", type=str, default="data/SPD/cooperative-vehicle-infrastructure/vehicle-side", + help="Raw data root about SPD") +parser.add_argument("--target-root", type=str, default="data/KITTI/cooperative-vehicle-infrastructure/vehicle-side", + help="The data root where the data with kitti format is generated") +parser.add_argument("--split-path", type=str, default="data/split_datas/cooperative-split-data-spd.json", + help="Json file to split the data into training/validation/testing.") +parser.add_argument("--label-type", type=str, default="lidar", help="label type from ['lidar', 'camera']") +parser.add_argument("--sensor-view", type=str, default="vehicle", help="Sensor view from ['infrastructure', 'vehicle']") +parser.add_argument("--no-classmerge", action="store_true", + help="Not to merge the four classes [Car, Truck, Van, Bus] into one class [Car]") +parser.add_argument("--temp-root", type=str, default="./tmp_file", help="Temporary intermediate file root.") + + +def rawdata_copy(source_root, target_root, dict_sequence2tvt, frame_info): + for i in track(frame_info): + # copy image + source_image_path = f'{source_root}/{i["image_path"]}' + target_image_path = f'{target_root}/{dict_sequence2tvt[i["sequence_id"]]}/image_2' + if not os.path.exists(target_image_path): + os.makedirs(target_image_path) + os.system("cp %s %s/" % (source_image_path, target_image_path)) + # copy point cloud + source_velodyne_pcd_path = f'{source_root}/{i["pointcloud_path"]}' + source_velodyne_bin_path = source_velodyne_pcd_path.replace(".pcd", ".bin") + target_velodyne_path = f'{target_root}/{dict_sequence2tvt[i["sequence_id"]]}/velodyne' + if not os.path.exists(target_velodyne_path): + os.makedirs(target_velodyne_path) + if not os.path.exists(source_velodyne_bin_path): + pcd2bin(source_velodyne_pcd_path, f'{target_velodyne_path}/{i["frame_id"]}.bin') + else: + os.system("cp %s %s/" % (source_velodyne_bin_path, target_velodyne_path)) + + +if __name__ == "__main__": + print("================ Start to Convert ================") + args = parser.parse_args() + source_root = args.source_root + target_root = args.target_root + split_path = args.split_path + split_info = read_json(split_path) + dict_sequence2tvt = {} + for tvt in [["train", "training"], ["val", "training"], ["test", "testing"]]: + for seq in split_info["batch_split"][tvt[0]]: + dict_sequence2tvt[seq] = tvt[1] + frame_info = read_json(f'{source_root}/data_info.json') + + print("================ Start to Copy Raw Data ================") + rawdata_copy(source_root, target_root, dict_sequence2tvt, frame_info) + + print("================ Start to Generate Label ================") + temp_root = args.temp_root + label_type = args.label_type + sensor_view = args.sensor_view + no_classmerge = args.no_classmerge + if os.path.exists(temp_root): + os.system("rm -rf %s" % temp_root) + os.system("mkdir -p %s" % temp_root) + label_dair2kitti(source_root, temp_root, dict_sequence2tvt, frame_info, label_type, sensor_view, no_classmerge) + os.system("cp -r %s/* %s/" % (temp_root, target_root)) + os.system("rm -rf %s" % temp_root) + + print("================ Start to Generate Calibration Files ================") + gen_calib2kitti(source_root, target_root, dict_sequence2tvt, sensor_view) + + print("================ Start to Generate ImageSet Files ================") + gen_ImageSet(target_root, split_info, sensor_view) diff --git a/tools/dataset_converter/spd2kitti_detection/gen_kitti/calib_dair2kitti.py b/tools/dataset_converter/spd2kitti_detection/gen_kitti/calib_dair2kitti.py new file mode 100644 index 0000000..947a3c3 --- /dev/null +++ b/tools/dataset_converter/spd2kitti_detection/gen_kitti/calib_dair2kitti.py @@ -0,0 +1,65 @@ +import os +import numpy as np +from rich.progress import track +from tools.dataset_converter.utils import read_json, get_lidar2camera, get_cam_calib_intrinsic + + +def convert_calib_dair2kitti(cam_intrinsic, r_velo2cam, t_velo2cam): + P2 = cam_intrinsic.reshape(12, order="C") + + Tr_velo_to_cam = np.concatenate((r_velo2cam, t_velo2cam), axis=1) + Tr_velo_to_cam = Tr_velo_to_cam.reshape(12, order="C") + + return P2, Tr_velo_to_cam + + +def gen_calib2kitti(source_root, target_root, dict_sequence2tvt, sensor_view): + data_info = read_json(f'{source_root}/data_info.json') + for i in track(data_info): + target_calib_path = f'{target_root}/{dict_sequence2tvt[i["sequence_id"]]}/calib' + if not os.path.exists(target_calib_path): + os.makedirs(target_calib_path) + target_calib_file_path = f'{target_calib_path}/{i["frame_id"]}.txt' + calib_camera_intrinsic_path = f'{source_root}/{i["calib_camera_intrinsic_path"]}' + cam_intrinsic = get_cam_calib_intrinsic(calib_camera_intrinsic_path) + if (sensor_view == "vehicle") or (sensor_view == "cooperative"): + calib_lidar_to_camera_path = f'{source_root}/{i["calib_lidar_to_camera_path"]}' + r_velo2cam, t_velo2cam = get_lidar2camera(calib_lidar_to_camera_path) + else: + calib_lidar_to_camera_path = f'{source_root}/{i["calib_virtuallidar_to_camera_path"]}' + r_velo2cam, t_velo2cam = get_lidar2camera(calib_lidar_to_camera_path) + + P2, Tr_velo_to_cam = convert_calib_dair2kitti(cam_intrinsic, r_velo2cam, t_velo2cam) + + str_P2 = "P2: " + str_Tr_velo_to_cam = "Tr_velo_to_cam: " + # str_Tr_imu_to_velo = "Tr_imu_to_velo: " + for m in range(11): + str_P2 = str_P2 + str(P2[m]) + " " + str_Tr_velo_to_cam = str_Tr_velo_to_cam + str(Tr_velo_to_cam[m]) + " " + str_P2 = str_P2 + str(P2[11]) + str_Tr_velo_to_cam = str_Tr_velo_to_cam + str(Tr_velo_to_cam[11]) + str_Tr_imu_to_velo = str_Tr_velo_to_cam + + str_P0 = str_P2 + str_P1 = str_P2 + str_P3 = str_P2 + str_R0_rect = "R0_rect: 1 0 0 0 1 0 0 0 1" + + with open(target_calib_file_path, "w") as save_file: + gt_line = ( + str_P0 + + "\n" + + str_P1 + + "\n" + + str_P2 + + "\n" + + str_P3 + + "\n" + + str_R0_rect + + "\n" + + str_Tr_velo_to_cam + + "\n" + + str_Tr_imu_to_velo + ) + save_file.write(gt_line) diff --git a/tools/dataset_converter/spd2kitti_detection/gen_kitti/gen_ImageSets_from_split_data.py b/tools/dataset_converter/spd2kitti_detection/gen_kitti/gen_ImageSets_from_split_data.py new file mode 100644 index 0000000..257e7eb --- /dev/null +++ b/tools/dataset_converter/spd2kitti_detection/gen_kitti/gen_ImageSets_from_split_data.py @@ -0,0 +1,34 @@ +import os +from tools.dataset_converter.utils import write_txt + + +def gen_ImageSet(target_root, split_info, sensor_view="vehicle"): + target_ImageSets_path = f'{target_root}/ImageSets' + if not os.path.exists(target_ImageSets_path): + os.makedirs(target_ImageSets_path) + test_file = "" + train_file = "" + val_file = "" + + sensor_view = sensor_view + "_split" + split_data = split_info[sensor_view] + for i in range(len(split_data["train"])): + name = split_data["train"][i] + train_file = train_file + name + "\n" + + for i in range(len(split_data["val"])): + name = split_data["val"][i] + val_file = val_file + name + "\n" + + # The test part of the dataset has not been released + # for i in range(len(split_data["test"])): + # name = split_data["test"][i] + # test_file = test_file + name + "\n" + + trainval_file = train_file + val_file + + write_txt(os.path.join(target_ImageSets_path, "test.txt"), test_file) + write_txt(os.path.join(target_ImageSets_path, "trainval.txt"), trainval_file) + write_txt(os.path.join(target_ImageSets_path, "train.txt"), train_file) + write_txt(os.path.join(target_ImageSets_path, "val.txt"), val_file) + diff --git a/tools/dataset_converter/spd2kitti_detection/gen_kitti/label_dair2kitti.py b/tools/dataset_converter/spd2kitti_detection/gen_kitti/label_dair2kitti.py new file mode 100644 index 0000000..39ba054 --- /dev/null +++ b/tools/dataset_converter/spd2kitti_detection/gen_kitti/label_dair2kitti.py @@ -0,0 +1,55 @@ +import os +from tools.dataset_converter.utils import read_json, get_lidar2camera, trans_point, get_lidar_3d_8points, get_camera_3d_alpha_rotation +from rich.progress import track + + +def label_dair2kiiti_by_frame(dair_label_file_path, kitti_label_file_path, rotation, translation, no_classmerge): + save_file = open(kitti_label_file_path, 'w') + list_labels = read_json(dair_label_file_path) + for label in list_labels: + if not no_classmerge: + label["type"] = label["type"].replace("Truck", "Car") + label["type"] = label["type"].replace("Van", "Car") + label["type"] = label["type"].replace("Bus", "Car") + label_3d_dimensions = [float(label["3d_dimensions"]["l"]), float(label["3d_dimensions"]["w"]), + float(label["3d_dimensions"]["h"])] + lidar_3d_location = [float(label["3d_location"]["x"]), float(label["3d_location"]["y"]), + float(label["3d_location"]["z"])] + rotation_z = float(label["rotation"]) + lidar_3d_8_points = get_lidar_3d_8points(label_3d_dimensions, lidar_3d_location, rotation_z) + + lidar_3d_bottom_location = [float(label["3d_location"]["x"]), float(label["3d_location"]["y"]), + float(label["3d_location"]["z"]) - float(label["3d_dimensions"]["h"]) / 2] + camera_3d_location = trans_point(lidar_3d_bottom_location, rotation, translation) + camera_3d_8_points = [] + for lidar_point in lidar_3d_8_points: + camera_point = trans_point(lidar_point, rotation, translation) + camera_3d_8_points.append(camera_point) + + alpha, rotation_y = get_camera_3d_alpha_rotation(camera_3d_8_points, camera_3d_location) + + list_item = [str(label["type"]), str(label["truncated_state"]), str(label["occluded_state"]), str(alpha), + str(label["2d_box"]["xmin"]), str(label["2d_box"]["ymin"]), str(label["2d_box"]["xmax"]), str(label["2d_box"]["ymax"]), + str(label_3d_dimensions[2]), str(label_3d_dimensions[1]), str(label_3d_dimensions[0]), str(camera_3d_location[0]), + str(camera_3d_location[1]), str(camera_3d_location[2]), str(rotation_y)] + str_item = ' '.join(list_item) + '\n' + save_file.writelines(str_item) + save_file.close() + + +def label_dair2kitti(source_root, temp_root, dict_sequence2tvt, frame_info, label_type, sensor_view, no_classmerge): + if (sensor_view == "vehicle") or (sensor_view == "cooperative"): + key_calib_l2c_path = "calib_lidar_to_camera_path" + else: + key_calib_l2c_path = "calib_virtuallidar_to_camera_path" + for i in track(frame_info): + calib_l2c_path = i[key_calib_l2c_path] + calib_lidar_to_camera_path = f'{source_root}/{calib_l2c_path}' + rotation, translation = get_lidar2camera(calib_lidar_to_camera_path) + label_std_path = i["label_" + label_type + "_std_path"] + source_label_path = f'{source_root}/{label_std_path}' + temp_label_path = f'{temp_root}/{dict_sequence2tvt[i["sequence_id"]]}/label_2' + if not os.path.exists(temp_label_path): + os.makedirs(temp_label_path) + temp_label_file_path = f'{temp_label_path}/{i["frame_id"]}.txt' + label_dair2kiiti_by_frame(source_label_path, temp_label_file_path, rotation, translation, no_classmerge) diff --git a/tools/dataset_converter/spd2kitti_tracking/README.md b/tools/dataset_converter/spd2kitti_tracking/README.md new file mode 100644 index 0000000..2cc7543 --- /dev/null +++ b/tools/dataset_converter/spd2kitti_tracking/README.md @@ -0,0 +1,31 @@ +# Convert SPD to KITTI-Track format + +## Install pypcd + +```bash +git clone https://github.com/klintan/pypcd.git +cd pypcd/ +python setup.py install +``` + +## SPD -> KITTI-Track + +```bash +python tools/dataset_converter/dair2kitti.py \ +--source-root data/SPD/cooperative-vehicle-infrastructure/vehicle-side \ +--target-root data/KITTI-Track/cooperative-vehicle-infrastructure/vehicle-side \ +--split-path data/split_datas/cooperative-split-data-spd.json \ +--label-type lidar \ +--sensor-view vehicle \ +--no-classmerge +``` + +````bash +python tools/dataset_converter/dair2kitti.py \ +--source-root data/SPD/cooperative-vehicle-infrastructure/infrastructure-side \ +--target-root data/KITTI-Track/cooperative-vehicle-infrastructure/infrastructure-side \ +--split-path data/split_datas/cooperative-split-data-spd.json \ +--label-type lidar \ +--sensor-view infrastructure \ +--no-classmerge +```` diff --git a/tools/dataset_converter/spd2kitti_tracking/coop_label_dair2kitti.py b/tools/dataset_converter/spd2kitti_tracking/coop_label_dair2kitti.py new file mode 100644 index 0000000..97dfa71 --- /dev/null +++ b/tools/dataset_converter/spd2kitti_tracking/coop_label_dair2kitti.py @@ -0,0 +1,111 @@ +import os +import argparse +from tools.dataset_converter.utils import read_json, get_lidar2camera, trans_point, get_lidar_3d_8points, get_camera_3d_alpha_rotation +from rich.progress import track + +parser = argparse.ArgumentParser("Generate the Kitti Format Data") +parser.add_argument("--source-root", type=str, default="data/V2X-Seq-SPD", + help="Raw data root about SPD") +parser.add_argument("--target-root", type=str, default="data/KITTI-Track/cooperative", + help="The data root where the data with kitti-Track format is generated") +parser.add_argument("--split-path", type=str, default="data/split_datas/cooperative-split-data-spd.json", + help="Json file to split the data into training/validation/testing.") +parser.add_argument("--no-classmerge", action="store_true", + help="Not to merge the four classes [Car, Truck, Van, Bus] into one class [Car]") +parser.add_argument("--temp-root", type=str, default="./tmp_file", help="Temporary intermediate file root.") + + +def concat_txt(input_path, output_path, output_file_name): + if not os.path.exists(output_path): + os.makedirs(output_path) + path_file_output = output_path + '/' + output_file_name + '.txt' + write_f = open(path_file_output, 'w') + list_files = os.listdir(input_path) + list_files.sort() + for file in list_files: + path_file_input = input_path + '/' + file + with open(path_file_input, 'r') as read_f: + list_lines = read_f.readlines() + for line in list_lines: + write_f.writelines(line) + write_f.close() + + +def label_dair2kiiti_by_frame(dair_label_file_path, kitti_label_file_path, rotation, translation, frame, pointcloud_timestamp, + no_classmerge): + save_file = open(kitti_label_file_path, 'w') + list_labels = read_json(dair_label_file_path) + for label in list_labels: + if not no_classmerge: + label["type"] = label["type"].replace("Truck", "Car") + label["type"] = label["type"].replace("Van", "Car") + label["type"] = label["type"].replace("Bus", "Car") + label_3d_dimensions = [float(label["3d_dimensions"]["l"]), float(label["3d_dimensions"]["w"]), + float(label["3d_dimensions"]["h"])] + lidar_3d_location = [float(label["3d_location"]["x"]), float(label["3d_location"]["y"]), + float(label["3d_location"]["z"])] + rotation_z = float(label["rotation"]) + lidar_3d_8_points = get_lidar_3d_8points(label_3d_dimensions, lidar_3d_location, rotation_z) + + lidar_3d_bottom_location = [float(label["3d_location"]["x"]), float(label["3d_location"]["y"]), + float(label["3d_location"]["z"]) - float(label["3d_dimensions"]["h"]) / 2] + camera_3d_location = trans_point(lidar_3d_bottom_location, rotation, translation) + camera_3d_8_points = [] + for lidar_point in lidar_3d_8_points: + camera_point = trans_point(lidar_point, rotation, translation) + camera_3d_8_points.append(camera_point) + + alpha, rotation_y = get_camera_3d_alpha_rotation(camera_3d_8_points, camera_3d_location) + + list_item = [frame, str(label["type"]), str(label["track_id"]), + str(label["truncated_state"]), str(label["occluded_state"]), str(alpha), + str(label["2d_box"]["xmin"]), str(label["2d_box"]["ymin"]), + str(label["2d_box"]["xmax"]), str(label["2d_box"]["ymax"]), str(label_3d_dimensions[2]), + str(label_3d_dimensions[1]), str(label_3d_dimensions[0]), str(camera_3d_location[0]), + str(camera_3d_location[1]), str(camera_3d_location[2]), str(rotation_y), str(lidar_3d_location[0]), + str(lidar_3d_location[1]), str(lidar_3d_location[2]), str(rotation_z), pointcloud_timestamp, "1", "1", + str(label["token"])] + str_item = ' '.join(list_item) + '\n' + save_file.writelines(str_item) + save_file.close() + + +def label_dair2kitti(source_root, target_root, temp_root, dict_sequence2tvt, frame_info, no_classmerge): + for i in track(frame_info): + calib_lidar_to_camera_path = f'{source_root}/vehicle-side/calib/lidar_to_camera/{i["vehicle_frame"]}.json' + rotation, translation = get_lidar2camera(calib_lidar_to_camera_path) + source_label_path = f'{source_root}/cooperative/label/{i["vehicle_frame"]}.json' + temp_label_path = f'{temp_root}/{dict_sequence2tvt[i["vehicle_sequence"]]}/{i["vehicle_sequence"]}/label_02_split' + os.makedirs(temp_label_path, exist_ok=True) + temp_label_file_path = f'{temp_label_path}/{i["vehicle_frame"]}.txt' + label_dair2kiiti_by_frame(source_label_path, temp_label_file_path, rotation, translation, i["vehicle_frame"], "-1", no_classmerge) + + list_tvt = os.listdir(temp_root) + for tvt in list_tvt: + temp_tvt_path = f'{temp_root}/{tvt}' + list_seqs = os.listdir(temp_tvt_path) + for seq in list_seqs: + temp_label_path = f'{temp_tvt_path}/{seq}/label_02_split' + target_label_path = f'{target_root}/{tvt}/{seq}/label_02' + concat_txt(temp_label_path, target_label_path, seq) + + +if __name__ == "__main__": + args = parser.parse_args() + spd_data_root = args.source_root + target_root = args.target_root + split_path = args.split_path + split_info = read_json(split_path) + dict_sequence2tvt = {} + for tvt in [["train", "training"], ["val", "validation"], ["test", "testing"]]: + for seq in split_info["batch_split"][tvt[0]]: + dict_sequence2tvt[seq] = tvt[1] + frame_info = read_json(f'{spd_data_root}/cooperative/data_info.json') + temp_root = args.temp_root + no_classmerge = args.no_classmerge + if os.path.exists(temp_root): + os.system("rm -rf %s" % temp_root) + os.system("mkdir -p %s" % temp_root) + label_dair2kitti(spd_data_root, target_root, temp_root, dict_sequence2tvt, frame_info, no_classmerge) + os.system("cp -r %s/* %s/" % (temp_root, target_root)) + os.system("rm -rf %s" % temp_root) diff --git a/tools/dataset_converter/spd2kitti_tracking/dair2kitti.py b/tools/dataset_converter/spd2kitti_tracking/dair2kitti.py new file mode 100644 index 0000000..c5da755 --- /dev/null +++ b/tools/dataset_converter/spd2kitti_tracking/dair2kitti.py @@ -0,0 +1,71 @@ +import argparse +import os +from tools.dataset_converter.spd2kitti_tracking.gen_kitti.label_dair2kitti import label_dair2kitti +from tools.dataset_converter.spd2kitti_tracking.gen_kitti.calib_dair2kitti import gen_calib2kitti +from tools.dataset_converter.spd2kitti_tracking.gen_kitti.gen_ImageSets_from_split_data import gen_ImageSet +from tools.dataset_converter.utils import read_json +from rich.progress import track + +parser = argparse.ArgumentParser("Generate the Kitti Format Data") +parser.add_argument("--source-root", type=str, default="data/SPD/cooperative-vehicle-infrastructure/vehicle-side", + help="Raw data root about SPD") +parser.add_argument("--target-root", type=str, default="data/KITTI-Track/cooperative-vehicle-infrastructure/vehicle-side", + help="The data root where the data with kitti-Track format is generated") +parser.add_argument("--split-path", type=str, default="data/split_datas/cooperative-split-data-spd.json", + help="Json file to split the data into training/validation/testing.") +parser.add_argument("--label-type", type=str, default="lidar", help="label type from ['lidar', 'camera']") +parser.add_argument("--sensor-view", type=str, default="vehicle", help="Sensor view from ['infrastructure', 'vehicle']") +parser.add_argument("--no-classmerge", action="store_true", + help="Not to merge the four classes [Car, Truck, Van, Bus] into one class [Car]") +parser.add_argument("--temp-root", type=str, default="./tmp_file", help="Temporary intermediate file root.") + + +def rawdata_copy(source_root, target_root, dict_sequence2tvt, frame_info): + for i in track(frame_info): + # copy image + source_image_path = f'{source_root}/{i["image_path"]}' + target_image_path = f'{target_root}/{dict_sequence2tvt[i["sequence_id"]]}/{i["sequence_id"]}/image_02' + if not os.path.exists(target_image_path): + os.makedirs(target_image_path) + os.system("cp %s %s/" % (source_image_path, target_image_path)) + # copy point cloud + source_velodyne_path = f'{source_root}/{i["pointcloud_path"]}' + target_velodyne_path = f'{target_root}/{dict_sequence2tvt[i["sequence_id"]]}/{i["sequence_id"]}/velodyne' + if not os.path.exists(target_velodyne_path): + os.makedirs(target_velodyne_path) + os.system("cp %s %s/" % (source_velodyne_path, target_velodyne_path)) + + +if __name__ == "__main__": + print("================ Start to Convert ================") + args = parser.parse_args() + source_root = args.source_root + target_root = args.target_root + split_path = args.split_path + split_info = read_json(split_path) + dict_sequence2tvt = {} + for tvt in [["train", "training"], ["val", "validation"], ["test", "testing"]]: + for seq in split_info["batch_split"][tvt[0]]: + dict_sequence2tvt[seq] = tvt[1] + frame_info = read_json(f'{source_root}/data_info.json') + + print("================ Start to Copy Raw Data ================") + rawdata_copy(source_root, target_root, dict_sequence2tvt, frame_info) + + print("================ Start to Generate Label ================") + temp_root = args.temp_root + label_type = args.label_type + sensor_view = args.sensor_view + no_classmerge = args.no_classmerge + if os.path.exists(temp_root): + os.system("rm -rf %s" % temp_root) + os.system("mkdir -p %s" % temp_root) + label_dair2kitti(source_root, target_root, temp_root, dict_sequence2tvt, frame_info, label_type, sensor_view, no_classmerge) + os.system("cp -r %s/* %s/" % (temp_root, target_root)) + os.system("rm -rf %s" % temp_root) + + print("================ Start to Generate Calibration Files ================") + gen_calib2kitti(source_root, target_root, dict_sequence2tvt, sensor_view) + + print("================ Start to Generate ImageSet Files ================") + gen_ImageSet(target_root, split_info) diff --git a/tools/dataset_converter/spd2kitti_tracking/gen_kitti/calib_dair2kitti.py b/tools/dataset_converter/spd2kitti_tracking/gen_kitti/calib_dair2kitti.py new file mode 100644 index 0000000..bebaf4b --- /dev/null +++ b/tools/dataset_converter/spd2kitti_tracking/gen_kitti/calib_dair2kitti.py @@ -0,0 +1,75 @@ +import os +import numpy as np +from rich.progress import track +from tools.dataset_converter.utils import read_json, inverse_matrix, get_lidar2camera, get_lidar2novatel, get_cam_calib_intrinsic + + +def convert_calib_dair2kitti(cam_intrinsic, r_velo2cam, t_velo2cam, r_novatel2velo, t_novatel2velo): + P2 = cam_intrinsic.reshape(12, order="C") + + Tr_velo_to_cam = np.concatenate((r_velo2cam, t_velo2cam), axis=1) + Tr_velo_to_cam = Tr_velo_to_cam.reshape(12, order="C") + + Tr_imu_to_velo = np.concatenate((r_novatel2velo, t_novatel2velo), axis=1) + Tr_imu_to_velo = Tr_imu_to_velo.reshape(12, order="C") + + return P2, Tr_velo_to_cam, Tr_imu_to_velo + + +def gen_calib2kitti(source_root, target_root, dict_sequence2tvt, sensor_view): + data_info = read_json(f'{source_root}/data_info.json') + for i in track(data_info): + target_calib_path = f'{target_root}/{dict_sequence2tvt[i["sequence_id"]]}/{i["sequence_id"]}/calib' + if not os.path.exists(target_calib_path): + os.makedirs(target_calib_path) + target_calib_file_path = f'{target_calib_path}/{i["frame_id"]}.txt' + calib_camera_intrinsic_path = f'{source_root}/{i["calib_camera_intrinsic_path"]}' + cam_intrinsic = get_cam_calib_intrinsic(calib_camera_intrinsic_path) + if sensor_view == "vehicle": + calib_lidar_to_camera_path = f'{source_root}/{i["calib_lidar_to_camera_path"]}' + r_velo2cam, t_velo2cam = get_lidar2camera(calib_lidar_to_camera_path) + calib_lidar_to_novatel_path = f'{source_root}/{i["calib_lidar_to_novatel_path"]}' + r_velo2imu, t_velo2imu = get_lidar2novatel(calib_lidar_to_novatel_path) + r_imu2velo = inverse_matrix(r_velo2imu) + t_imu2velo = - np.dot(r_imu2velo, t_velo2imu) + else: + calib_lidar_to_camera_path = f'{source_root}/{i["calib_virtuallidar_to_camera_path"]}' + r_velo2cam, t_velo2cam = get_lidar2camera(calib_lidar_to_camera_path) + r_imu2velo = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) + t_imu2velo = - np.array([[0], [0], [0]]) + + P2, Tr_velo_to_cam, Tr_imu_to_velo = convert_calib_dair2kitti(cam_intrinsic, r_velo2cam, t_velo2cam, r_imu2velo, t_imu2velo) + + str_P2 = "P2: " + str_Tr_velo_to_cam = "Tr_velo_to_cam: " + str_Tr_imu_to_velo = "Tr_imu_to_velo: " + for m in range(11): + str_P2 = str_P2 + str(P2[m]) + " " + str_Tr_velo_to_cam = str_Tr_velo_to_cam + str(Tr_velo_to_cam[m]) + " " + str_Tr_imu_to_velo = str_Tr_imu_to_velo + str(Tr_imu_to_velo[m]) + " " + str_P2 = str_P2 + str(P2[11]) + str_Tr_velo_to_cam = str_Tr_velo_to_cam + str(Tr_velo_to_cam[11]) + str_Tr_imu_to_velo = str_Tr_imu_to_velo + str(Tr_imu_to_velo[11]) + + str_P0 = str_P2.replace("P2", "P0") + str_P1 = str_P2.replace("P2", "P1") + str_P3 = str_P2.replace("P2", "P3") + str_R0_rect = "R0_rect: 1 0 0 0 1 0 0 0 1" + + with open(target_calib_file_path, "w") as save_file: + gt_line = ( + str_P0 + + "\n" + + str_P1 + + "\n" + + str_P2 + + "\n" + + str_P3 + + "\n" + + str_R0_rect + + "\n" + + str_Tr_velo_to_cam + + "\n" + + str_Tr_imu_to_velo + ) + save_file.write(gt_line) diff --git a/tools/dataset_converter/spd2kitti_tracking/gen_kitti/gen_ImageSets_from_split_data.py b/tools/dataset_converter/spd2kitti_tracking/gen_kitti/gen_ImageSets_from_split_data.py new file mode 100644 index 0000000..14f5c66 --- /dev/null +++ b/tools/dataset_converter/spd2kitti_tracking/gen_kitti/gen_ImageSets_from_split_data.py @@ -0,0 +1,37 @@ +import os +from tools.dataset_converter.utils import write_txt + + +def gen_ImageSet(target_root, split_info): + target_ImageSets_path = f'{target_root}/ImageSets' + if not os.path.exists(target_ImageSets_path): + os.makedirs(target_ImageSets_path) + + list_train_seqs = split_info["batch_split"]["train"] + list_val_seqs = split_info["batch_split"]["val"] + list_trainval_seqs = list_train_seqs + list_val_seqs + list_test_seqs = split_info["batch_split"]["test"] + list_train_seqs.sort() + list_val_seqs.sort() + list_trainval_seqs.sort() + list_test_seqs.sort() + + str_train_seqs = "" + str_val_seqs = "" + str_trainval_seqs = "" + str_test_seqs = "" + + for train_seq in list_train_seqs: + str_train_seqs = str_train_seqs + train_seq + "\n" + for val_seq in list_val_seqs: + str_val_seqs = str_val_seqs + val_seq + "\n" + for trainval_seq in list_trainval_seqs: + str_trainval_seqs = str_trainval_seqs + trainval_seq + "\n" + for test_seq in list_test_seqs: + str_test_seqs = str_test_seqs + test_seq + "\n" + + write_txt(target_ImageSets_path + "/train.txt", str_train_seqs) + write_txt(target_ImageSets_path + "/val.txt", str_val_seqs) + write_txt(target_ImageSets_path + "/trainval.txt", str_trainval_seqs) + write_txt(target_ImageSets_path + "/test.txt", str_test_seqs) + diff --git a/tools/dataset_converter/spd2kitti_tracking/gen_kitti/label_dair2kitti.py b/tools/dataset_converter/spd2kitti_tracking/gen_kitti/label_dair2kitti.py new file mode 100644 index 0000000..48fc9fb --- /dev/null +++ b/tools/dataset_converter/spd2kitti_tracking/gen_kitti/label_dair2kitti.py @@ -0,0 +1,84 @@ +import os +from tools.dataset_converter.utils import read_json, get_lidar2camera, trans_point, get_lidar_3d_8points, get_camera_3d_alpha_rotation +from rich.progress import track + + +def concat_txt(input_path, output_path, output_file_name): + if not os.path.exists(output_path): + os.makedirs(output_path) + path_file_output = output_path + '/' + output_file_name + '.txt' + write_f = open(path_file_output, 'w') + list_files = os.listdir(input_path) + list_files.sort() + for file in list_files: + path_file_input = input_path + '/' + file + with open(path_file_input, 'r') as read_f: + list_lines = read_f.readlines() + for line in list_lines: + write_f.writelines(line) + write_f.close() + + +def label_dair2kiiti_by_frame(dair_label_file_path, kitti_label_file_path, rotation, translation, frame, pointcloud_timestamp, no_classmerge): + save_file = open(kitti_label_file_path, 'w') + list_labels = read_json(dair_label_file_path) + for label in list_labels: + if not no_classmerge: + label["type"] = label["type"].replace("Truck", "Car") + label["type"] = label["type"].replace("Van", "Car") + label["type"] = label["type"].replace("Bus", "Car") + label_3d_dimensions = [float(label["3d_dimensions"]["l"]), float(label["3d_dimensions"]["w"]), + float(label["3d_dimensions"]["h"])] + lidar_3d_location = [float(label["3d_location"]["x"]), float(label["3d_location"]["y"]), + float(label["3d_location"]["z"])] + rotation_z = float(label["rotation"]) + lidar_3d_8_points = get_lidar_3d_8points(label_3d_dimensions, lidar_3d_location, rotation_z) + + lidar_3d_bottom_location = [float(label["3d_location"]["x"]), float(label["3d_location"]["y"]), + float(label["3d_location"]["z"]) - float(label["3d_dimensions"]["h"]) / 2] + camera_3d_location = trans_point(lidar_3d_bottom_location, rotation, translation) + camera_3d_8_points = [] + for lidar_point in lidar_3d_8_points: + camera_point = trans_point(lidar_point, rotation, translation) + camera_3d_8_points.append(camera_point) + + alpha, rotation_y = get_camera_3d_alpha_rotation(camera_3d_8_points, camera_3d_location) + + list_item = [frame, str(label["type"]), str(label["track_id"]), + str(label["truncated_state"]), str(label["occluded_state"]), str(alpha), + str(label["2d_box"]["xmin"]), str(label["2d_box"]["ymin"]), + str(label["2d_box"]["xmax"]), str(label["2d_box"]["ymax"]), str(label_3d_dimensions[2]), + str(label_3d_dimensions[1]), str(label_3d_dimensions[0]), str(camera_3d_location[0]), + str(camera_3d_location[1]), str(camera_3d_location[2]), str(rotation_y), str(lidar_3d_location[0]), + str(lidar_3d_location[1]), str(lidar_3d_location[2]), str(rotation_z), pointcloud_timestamp, "1", "1", + str(label["token"])] + str_item = ' '.join(list_item) + '\n' + save_file.writelines(str_item) + save_file.close() + + +def label_dair2kitti(source_root, target_root, temp_root, dict_sequence2tvt, frame_info, label_type, sensor_view, no_classmerge): + if (sensor_view == "vehicle") or (sensor_view == "cooperative"): + key_calib_l2c_path = "calib_lidar_to_camera_path" + else: + key_calib_l2c_path = "calib_virtuallidar_to_camera_path" + for i in track(frame_info): + calib_l2c_path = i[key_calib_l2c_path] + calib_lidar_to_camera_path = f'{source_root}/{calib_l2c_path}' + rotation, translation = get_lidar2camera(calib_lidar_to_camera_path) + label_std_path = i["label_" + label_type + "_std_path"] + source_label_path = f'{source_root}/{label_std_path}' + temp_label_path = f'{temp_root}/{dict_sequence2tvt[i["sequence_id"]]}/{i["sequence_id"]}/label_02_split' + if not os.path.exists(temp_label_path): + os.makedirs(temp_label_path) + temp_label_file_path = f'{temp_label_path}/{i["frame_id"]}.txt' + label_dair2kiiti_by_frame(source_label_path, temp_label_file_path, rotation, translation, i["frame_id"], i["pointcloud_timestamp"], no_classmerge) + + list_tvt = os.listdir(temp_root) + for tvt in list_tvt: + temp_tvt_path = f'{temp_root}/{tvt}' + list_seqs = os.listdir(temp_tvt_path) + for seq in list_seqs: + temp_label_path = f'{temp_tvt_path}/{seq}/label_02_split' + target_label_path = f'{target_root}/{tvt}/{seq}/label_02' + concat_txt(temp_label_path, target_label_path, seq) diff --git a/tools/dataset_converter/utils.py b/tools/dataset_converter/utils.py new file mode 100644 index 0000000..b6950b1 --- /dev/null +++ b/tools/dataset_converter/utils.py @@ -0,0 +1,222 @@ +import os +import math +import json +import errno +import numpy as np +import open3d as o3d +from pypcd import pypcd + + +def mkdir_p(path): + try: + os.makedirs(path) + except OSError as exc: # Python >2.5 + if exc.errno == errno.EEXIST and os.path.isdir(path): + pass + else: + raise + + +def get_files_path(path_my_dir, extention=".json"): + path_list = [] + for (dirpath, dirnames, filenames) in os.walk(path_my_dir): + for filename in filenames: + if os.path.splitext(filename)[1] == extention: + path_list.append(os.path.join(dirpath, filename)) + return path_list + + +def write_txt(path, file): + with open(path, "w") as f: + f.write(file) + + +def read_json(path): + with open(path, "r") as f: + my_json = json.load(f) + return my_json + + +def write_json(path_json, new_dict): + with open(path_json, "w") as f: + json.dump(new_dict, f) + + +def read_pcd(path_pcd): + pointpillar = o3d.io.read_point_cloud(path_pcd) + points = np.asarray(pointpillar.points) + points = points.tolist() + return points + + +def write_pcd(path_pcd, new_points, path_save): + pc = pypcd.PointCloud.from_path(path_pcd) + pc.pc_data['x'] = np.array([a[0] for a in new_points]) + pc.pc_data['y'] = np.array([a[1] for a in new_points]) + pc.pc_data['z'] = np.array([a[2] for a in new_points]) + pc.save_pcd(path_save, compression='binary_compressed') + + +def show_pcd(path_pcd): + pcd = read_pcd(path_pcd) + o3d.visualization.draw_geometries([pcd]) + + +def pcd2bin(pcd_file_path, bin_file_path): + pc = pypcd.PointCloud.from_path(pcd_file_path) + + np_x = (np.array(pc.pc_data["x"], dtype=np.float32)).astype(np.float32) + np_y = (np.array(pc.pc_data["y"], dtype=np.float32)).astype(np.float32) + np_z = (np.array(pc.pc_data["z"], dtype=np.float32)).astype(np.float32) + np_i = (np.array(pc.pc_data["intensity"], dtype=np.float32)).astype(np.float32) / 255 + + points_32 = np.transpose(np.vstack((np_x, np_y, np_z, np_i))) + points_32.tofile(bin_file_path) + + +def inverse_matrix(R): + R = np.matrix(R) + rev_R = R.I + rev_R = np.array(rev_R) + return rev_R + + +def trans_point(input_point, rotation, translation=None): + if translation is None: + translation = [0.0, 0.0, 0.0] + input_point = np.array(input_point).reshape(3, 1) + translation = np.array(translation).reshape(3, 1) + rotation = np.array(rotation).reshape(3, 3) + output_point = np.dot(rotation, input_point).reshape(3, 1) + np.array(translation).reshape(3, 1) + output_point = output_point.reshape(1, 3).tolist() + return output_point[0] + + +def trans(input_point, rotation, translation): + input_point = np.array(input_point).reshape(3, -1) + translation = np.array(translation).reshape(3, 1) + rotation = np.array(rotation).reshape(3, 3) + output_point = np.dot(rotation, input_point).reshape(3, -1) + np.array(translation).reshape(3, 1) + return output_point + + +def get_lidar_3d_8points(label_3d_dimensions, lidar_3d_location, rotation_z): + lidar_rotation = np.matrix( + [ + [math.cos(rotation_z), -math.sin(rotation_z), 0], + [math.sin(rotation_z), math.cos(rotation_z), 0], + [0, 0, 1] + ] + ) + l, w, h = label_3d_dimensions + corners_3d_lidar = np.matrix( + [ + [l / 2, l / 2, -l / 2, -l / 2, l / 2, l / 2, -l / 2, -l / 2], + [w / 2, -w / 2, -w / 2, w / 2, w / 2, -w / 2, -w / 2, w / 2], + [-h / 2, -h / 2, -h / 2, -h / 2, h / 2, h / 2, h / 2, h / 2], + ] + ) + lidar_3d_8points = lidar_rotation * corners_3d_lidar + np.matrix(lidar_3d_location).T + return lidar_3d_8points.T.tolist() + + +def get_label_lidar_rotation(lidar_3d_8_points): + """ + 计算 lidar 坐标系下的偏航角 rotation_z + 目标 3D 框示意图: + 4 -------- 5 + /| /| + 7 -------- 6 . + | | | | + . 0 -------- 1 + |/ |/ + 3 -------- 2 + Args: + lidar_3d_8_points: 八个角点组成的矩阵[[x,y,z],...] + Returns: + rotation_z: Lidar坐标系下的偏航角rotation_z (-pi,pi) rad + """ + x0, y0 = lidar_3d_8_points[0][0], lidar_3d_8_points[0][1] + x3, y3 = lidar_3d_8_points[3][0], lidar_3d_8_points[3][1] + dx, dy = x0 - x3, y0 - y3 + rotation_z = math.atan2(dy, dx) # Lidar坐标系xyz下的偏航角yaw绕z轴与x轴夹角，方向符合右手规则，所以用(dy,dx) + return rotation_z + + +def get_camera_3d_8points(label_3d_dimensions, camera_3d_location, rotation_y): + camera_rotation = np.matrix( + [ + [math.cos(rotation_y), 0, math.sin(rotation_y)], + [0, 1, 0], + [-math.sin(rotation_y), 0, math.cos(rotation_y)] + ] + ) + l, w, h = label_3d_dimensions + corners_3d_camera = np.matrix( + [ + [l / 2, l / 2, -l / 2, -l / 2, l / 2, l / 2, -l / 2, -l / 2], + [0, 0, 0, 0, -h, -h, -h, -h], + [w / 2, -w / 2, -w / 2, w / 2, w / 2, -w / 2, -w / 2, w / 2], + ] + ) + camera_3d_8points = camera_rotation * corners_3d_camera + np.matrix(camera_3d_location).T + return camera_3d_8points.T.tolist() + + +def get_camera_3d_alpha_rotation(camera_3d_8_points, camera_3d_location): + x0, z0 = camera_3d_8_points[0][0], camera_3d_8_points[0][2] + x3, z3 = camera_3d_8_points[3][0], camera_3d_8_points[3][2] + dx, dz = x0 - x3, z0 - z3 + rotation_y = -math.atan2(dz, dx) # 相机坐标系xyz下的偏航角yaw绕y轴与x轴夹角，方向符合右手规则，所以用(-dz,dx) + # alpha = rotation_y - math.atan2(center_in_cam[0], center_in_cam[2]) + alpha = rotation_y - (-math.atan2(-camera_3d_location[2], -camera_3d_location[0])) + math.pi / 2 # yzw + # add transfer + if alpha > math.pi: + alpha = alpha - 2.0 * math.pi + if alpha <= (-1 * math.pi): + alpha = alpha + 2.0 * math.pi + return alpha, rotation_y + + +def get_cam_calib_intrinsic(calib_path): + my_json = read_json(calib_path) + cam_K = my_json["cam_K"] + calib = np.zeros([3, 4]) + calib[:3, :3] = np.array(cam_K).reshape([3, 3], order="C") + return calib + + +def get_lidar2camera(path_lidar2camera): + lidar2camera = read_json(path_lidar2camera) + rotation = lidar2camera['rotation'] + translation = lidar2camera['translation'] + rotation = np.array(rotation).reshape(3, 3) + translation = np.array(translation).reshape(3, 1) + return rotation, translation + + +def get_lidar2novatel(path_lidar2novatel): + lidar2novatel = read_json(path_lidar2novatel) + rotation = lidar2novatel['transform']['rotation'] + translation = lidar2novatel['transform']['translation'] + rotation = np.array(rotation).reshape(3, 3) + translation = np.array(translation).reshape(3, 1) + return rotation, translation + + +def get_novatel2world(path_novatel2world): + novatel2world = read_json(path_novatel2world) + rotation = novatel2world['rotation'] + translation = novatel2world['translation'] + rotation = np.array(rotation).reshape(3, 3) + translation = np.array(translation).reshape(3, 1) + return rotation, translation + + +def get_virtuallidar2world(path_virtuallidar2world): + virtuallidar2world = read_json(path_virtuallidar2world) + rotation = virtuallidar2world['rotation'] + translation = virtuallidar2world['translation'] + rotation = np.array(rotation).reshape(3, 3) + translation = np.array(translation).reshape(3, 1) + return rotation, translation diff --git a/tools/visualize/gen_SUS_label.py b/tools/visualize/gen_SUS_label.py new file mode 100644 index 0000000..f594e12 --- /dev/null +++ b/tools/visualize/gen_SUS_label.py @@ -0,0 +1,204 @@ +import os +import json +import argparse +import pandas as pd + + +def read_json(path_json): + with open(path_json, "r") as load_f: + my_json = json.load(load_f) + return my_json + + +def write_json(path_json, new_dict): + with open(path_json, "w") as f: + json.dump(new_dict, f) + + +def gen_sus_label_from_dair_v2x(root_path, output_path): + """ + Generate SUS visualization file for DAIR-V2X label.(Take vehicle-side for example.) + + Args: + root_path: V2X-Seq-SPD/ + output_path： SUSTechPOINTS/data/output/ + + Returns: + None + """ + if not os.path.exists(output_path): + os.makedirs(output_path + '/label') + os.makedirs(output_path + '/lidar') + os.makedirs(output_path + '/calib') + os.makedirs(output_path + '/camera/front') + os.makedirs(output_path + '/camera/left') + os.makedirs(output_path + '/camera/right') + + veh_label_name = 'lidar' + + veh_img_path = os.path.join(root_path, 'vehicle-side/image') + veh_pt_path = os.path.join(root_path, 'vehicle-side/velodyne') + veh_label_path = os.path.join(root_path, 'vehicle-side/label', veh_label_name) + + list_input_file = os.listdir(veh_label_path) + for file_name in list_input_file: + veh_frame_id = file_name.split('.')[0] + + os.system("cp %s/%s.jpg %s/camera/front/%s.jpg" % ( + veh_img_path, veh_frame_id, output_path, veh_frame_id)) + os.system("cp %s/%s.pcd %s/lidar/%s.pcd" % ( + veh_pt_path, veh_frame_id, output_path, veh_frame_id)) + + cur_veh_label_path = os.path.join(veh_label_path, file_name) + + output_label_file_path = output_path + '/label/' + file_name + data_json = read_json(cur_veh_label_path) + lidar_3d_list = [] + for i in data_json: + lidar_3d_data = {} + lidar_3d_data["obj_id"] = str(i["track_id"]) + lidar_3d_data["obj_type"] = str(i["type"]) + lidar_3d_data["psr"] = {} + lidar_3d_data["psr"]["position"] = {} + lidar_3d_data["psr"]["position"]["x"] = float(i["3d_location"]["x"]) + lidar_3d_data["psr"]["position"]["y"] = float(i["3d_location"]["y"]) + lidar_3d_data["psr"]["position"]["z"] = float(i["3d_location"]["z"]) + lidar_3d_data["psr"]["rotation"] = {} + lidar_3d_data["psr"]["rotation"]["x"] = 0.0 + lidar_3d_data["psr"]["rotation"]["y"] = 0.0 + lidar_3d_data["psr"]["rotation"]["z"] = float(i["rotation"]) + lidar_3d_data["psr"]["scale"] = {} + lidar_3d_data["psr"]["scale"]["x"] = float(i["3d_dimensions"]["l"]) + lidar_3d_data["psr"]["scale"]["y"] = float(i["3d_dimensions"]["w"]) + lidar_3d_data["psr"]["scale"]["z"] = float(i["3d_dimensions"]["h"]) + # print(lidar_3d_data) + lidar_3d_list.append(lidar_3d_data) + write_json(output_label_file_path, lidar_3d_list) + + +def gen_sus_from_kitti_file(side_flag, only_gen_label, dair_datasets_path, input_file_path, output_path): + """ + Generate SUS visualization file for DAIR-V2X kitti label + + Args: + side_flag: 'coop','veh','inf', 'i2v' + dair_datasets_path: V2X-Seq-SPD/ + input_path: kitti_label_file (such as: cooperative-vehicle-infrastructure/infrastructure-side/validation/0003/label_02/0003.txt) + output_path: SUSTechPOINTS/data/output/ + + Returns: + None + """ + + if os.path.exists(output_path): + os.system('rm -rf %s' % (output_path)) + + output_path_label = os.path.join(output_path, 'label') + os.makedirs(output_path_label) + + if side_flag == 'i2v': + coop_data_info_file_path = os.path.join(dair_datasets_path, 'cooperative/data_info.json') + with open(coop_data_info_file_path) as f: + coop_data_info = json.load(f) + frameid_i2v_dict = {} + for coop_data in coop_data_info: + frameid_i2v_dict[coop_data['infrastructure_frame']] = coop_data['vehicle_frame'] + + if not only_gen_label: + output_path_lidar = os.path.join(output_path, 'lidar') + output_path_camera_front = os.path.join(output_path, 'camera/front') + os.makedirs(output_path_lidar) + os.makedirs(output_path_camera_front) + + if side_flag == 'inf': + img_path = os.path.join(dair_datasets_path, 'infrastructure-side/image') + velodyne_path = os.path.join(dair_datasets_path, 'infrastructure-side/velodyne') + elif side_flag == 'veh' or side_flag == 'coop': + img_path = os.path.join(dair_datasets_path, 'vehicle-side/image') + velodyne_path = os.path.join(dair_datasets_path, 'vehicle-side/velodyne') + elif side_flag == 'i2v': + img_path = os.path.join(dair_datasets_path, 'infrastructure-side/image') + velodyne_path = os.path.join(dair_datasets_path, 'vehicle-side/velodyne') + + if side_flag == 'coop': + names = ['frame', 'type', 'track_id', 'truncated', 'occlude', 'alpha', 'bbox-left', 'bbox-top', + 'bbox-right', 'bbox-bottom', 'h', 'w', 'l', 'camera_bottom_center_x', 'camera_bottom_center_y', + 'camera_bottom_center_z', 'rotation_y', 'lidar_center_x', 'lidar_center_y', 'lidar_center_z', + 'rotation_z', 'pointcloud_timestamp', 'score_dtc', 'score_tracking', 'token', 'from_side', + 'veh_pointcloud_timestamp', 'inf_pointcloud_timestamp', 'veh_frame_id', 'inf_frame_id', 'veh_track_id', + 'inf_track_id', 'veh_dtc_score', 'inf_dtc_score', 'veh_track_score', 'inf_track_score', 'veh_tocken', 'inf_tocken' + ] + else: + names = ['frame', 'type', 'track_id', 'truncated', 'occlude', 'alpha', 'bbox-left', 'bbox-top', + 'bbox-right', 'bbox-bottom', 'h', 'w', 'l', 'camera_bottom_center_x', 'camera_bottom_center_y', + 'camera_bottom_center_z', 'rotation_y', 'lidar_center_x', 'lidar_center_y', 'lidar_center_z', + 'rotation_z', 'pointcloud_timestamp', 'score_dtc', 'score_tracking', 'token' + ] + + df = pd.read_csv(input_file_path, sep=' ', header=None, names=names) + for frame in list(set(df['frame'])): + from_frame_id = '%06d' % int(frame) + to_frame_id = from_frame_id + + if side_flag == 'i2v': + to_frame_id = frameid_i2v_dict[from_frame_id] + + if not only_gen_label: + # lidar/camera + os.system("cp %s/%s.jpg %s/%s.jpg" % ( + img_path, from_frame_id, output_path_camera_front, to_frame_id)) + os.system("cp %s/%s.pcd %s/%s.pcd" % ( + velodyne_path, to_frame_id, output_path_lidar, to_frame_id)) + + # label + output_file_path = output_path_label + '/' + to_frame_id + '.json' + m = df[df['frame'] == frame] + lidar_3d_list = [] + for i, row in m.iterrows(): + lidar_3d_data = {} + + lidar_3d_data["obj_id"] = str(int(row['track_id'])).zfill(6) + lidar_3d_data["obj_type"] = row['type'] + if side_flag == 'coop': + lidar_3d_data["obj_type"] = row['type'] + ' ' + row['from_side'] + + lidar_3d_data["psr"] = {} + lidar_3d_data["psr"]["position"] = {} + lidar_3d_data["psr"]["position"]["x"] = float(row['lidar_center_x']) + lidar_3d_data["psr"]["position"]["y"] = float(row['lidar_center_y']) + lidar_3d_data["psr"]["position"]["z"] = float(row['lidar_center_z']) + lidar_3d_data["psr"]["rotation"] = {} + lidar_3d_data["psr"]["rotation"]["x"] = 0.0 + lidar_3d_data["psr"]["rotation"]["y"] = 0.0 + lidar_3d_data["psr"]["rotation"]["z"] = float(row['rotation_z']) + lidar_3d_data["psr"]["scale"] = {} + lidar_3d_data["psr"]["scale"]["x"] = float(row['l']) + lidar_3d_data["psr"]["scale"]["y"] = float(row['w']) + lidar_3d_data["psr"]["scale"]["z"] = float(row['h']) + # print(lidar_3d_data) + lidar_3d_list.append(lidar_3d_data) + write_json(output_file_path, lidar_3d_list) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser("3d visualization.") + parser.add_argument('--dair_datasets_path', type=str, default='V2X-Seq-SPD') + parser.add_argument('--input_file_path', type=str, default='') + parser.add_argument('--output_path', type=str, default='') + parser.add_argument('--side_flag', type=str, default='coop') # 'veh','inf','coop','i2v' + parser.add_argument('--only_gen_label', action="store_true") + + args = parser.parse_args() + print('begin visual.') + + # visualization + # #veh + # args.output_path = 'visualize/coop_seq0000' + # gen_sus_label_from_dair_v2x(args.dair_datasets_path,args.output_path) + + # kitti file + args.side_flag = "coop" # 'veh','inf','coop','i2v' + args.only_gen_label = True + args.input_file_path = 'kitti/cooperative-vehicle-infrastructure/cooperative/training/0000/label_02/0000.txt' + args.output_path = 'visualize/coop_seq0000' + gen_sus_from_kitti_file(args.side_flag, args.only_gen_label, args.dair_datasets_path, args.input_file_path, args.output_path) diff --git a/v2x/AB3DMOT_plugin/AB3DMOT_libs/__init__.py b/v2x/AB3DMOT_plugin/AB3DMOT_libs/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/v2x/AB3DMOT_plugin/AB3DMOT_libs/box.py b/v2x/AB3DMOT_plugin/AB3DMOT_libs/box.py new file mode 100755 index 0000000..2002150 --- /dev/null +++ b/v2x/AB3DMOT_plugin/AB3DMOT_libs/box.py @@ -0,0 +1,110 @@ +import numpy as np +from numba import jit +from copy import deepcopy +from .kitti_oxts import roty + +class Box3D: + def __init__(self, x=None, y=None, z=None, h=None, w=None, l=None, ry=None, s=None): + self.x = x # center x + self.y = y # center y + self.z = z # center z + self.h = h # height + self.w = w # width + self.l = l # length + self.ry = ry # orientation + self.s = s # detection score + self.corners_3d_cam = None + + def __str__(self): + return 'x: {}, y: {}, z: {}, heading: {}, length: {}, width: {}, height: {}, score: {}'.format( + self.x, self.y, self.z, self.ry, self.l, self.w, self.h, self.s) + + @classmethod + def bbox2dict(cls, bbox): + return { + 'center_x': bbox.x, 'center_y': bbox.y, 'center_z': bbox.z, + 'height': bbox.h, 'width': bbox.w, 'length': bbox.l, 'heading': bbox.ry} + + @classmethod + def bbox2array(cls, bbox): + if bbox.s is None: + return np.array([bbox.x, bbox.y, bbox.z, bbox.ry, bbox.l, bbox.w, bbox.h]) + else: + return np.array([bbox.x, bbox.y, bbox.z, bbox.ry, bbox.l, bbox.w, bbox.h, bbox.s]) + + @classmethod + def bbox2array_raw(cls, bbox): + if bbox.s is None: + return np.array([bbox.h, bbox.w, bbox.l, bbox.x, bbox.y, bbox.z, bbox.ry]) + else: + return np.array([bbox.h, bbox.w, bbox.l, bbox.x, bbox.y, bbox.z, bbox.ry, bbox.s]) + + @classmethod + def array2bbox_raw(cls, data): + # take the format of data of [h,w,l,x,y,z,theta] + + bbox = Box3D() + bbox.h, bbox.w, bbox.l, bbox.x, bbox.y, bbox.z, bbox.ry = data[:7] + if len(data) == 8: + bbox.s = data[-1] + return bbox + + @classmethod + def array2bbox(cls, data): + # take the format of data of [x,y,z,theta,l,w,h] + + bbox = Box3D() + bbox.x, bbox.y, bbox.z, bbox.ry, bbox.l, bbox.w, bbox.h = data[:7] + if len(data) == 8: + bbox.s = data[-1] + return bbox + + @classmethod + def box2corners3d_camcoord(cls, bbox): + ''' Takes an object's 3D box with the representation of [x,y,z,theta,l,w,h] and + convert it to the 8 corners of the 3D box, the box is in the camera coordinate + with right x, down y, front z + + Returns: + corners_3d: (8,3) array in in rect camera coord + + box corner order is like follows + 1 -------- 0 top is bottom because y direction is negative + /| /| + 2 -------- 3 . + | | | | + . 5 -------- 4 + |/ |/ + 6 -------- 7 + + rect/ref camera coord: + right x, down y, front z + + x -> w, z -> l, y -> h + ''' + + # if already computed before, then skip it + if bbox.corners_3d_cam is not None: + return bbox.corners_3d_cam + + # compute rotational matrix around yaw axis + # -1.57 means straight, so there is a rotation here + R = roty(bbox.ry) + + # 3d bounding box dimensions + l, w, h = bbox.l, bbox.w, bbox.h + + # 3d bounding box corners + x_corners = [l/2,l/2,-l/2,-l/2,l/2,l/2,-l/2,-l/2]; + y_corners = [0,0,0,0,-h,-h,-h,-h]; + z_corners = [w/2,-w/2,-w/2,w/2,w/2,-w/2,-w/2,w/2]; + + # rotate and translate 3d bounding box + corners_3d = np.dot(R, np.vstack([x_corners, y_corners, z_corners])) + corners_3d[0,:] = corners_3d[0,:] + bbox.x + corners_3d[1,:] = corners_3d[1,:] + bbox.y + corners_3d[2,:] = corners_3d[2,:] + bbox.z + corners_3d = np.transpose(corners_3d) + bbox.corners_3d_cam = corners_3d + + return corners_3d \ No newline at end of file diff --git a/v2x/AB3DMOT_plugin/AB3DMOT_libs/dist_metrics.py b/v2x/AB3DMOT_plugin/AB3DMOT_libs/dist_metrics.py new file mode 100755 index 0000000..e23c036 --- /dev/null +++ b/v2x/AB3DMOT_plugin/AB3DMOT_libs/dist_metrics.py @@ -0,0 +1,223 @@ +import numpy as np, time +from numba import jit +from scipy.spatial import ConvexHull +from .box import Box3D + +def polygon_clip(subjectPolygon, clipPolygon): + """ Clip a polygon with another polygon. + Ref: https://rosettacode.org/wiki/Sutherland-Hodgman_polygon_clipping#Python + + Args: + subjectPolygon: a list of (x,y) 2d points, any polygon. + clipPolygon: a list of (x,y) 2d points, has to be *convex* + Note: + **points have to be counter-clockwise ordered** + + Return: + a list of (x,y) vertex point for the intersection polygon. + """ + def inside(p): + return (cp2[0] - cp1[0]) * (p[1] - cp1[1]) > (cp2[1] - cp1[1]) * (p[0] - cp1[0]) + + def computeIntersection(): + dc = [cp1[0] - cp2[0], cp1[1] - cp2[1]] + dp = [s[0] - e[0], s[1] - e[1]] + n1 = cp1[0] * cp2[1] - cp1[1] * cp2[0] + n2 = s[0] * e[1] - s[1] * e[0] + n3 = 1.0 / (dc[0] * dp[1] - dc[1] * dp[0]) + return [(n1 * dp[0] - n2 * dc[0]) * n3, (n1 * dp[1] - n2 * dc[1]) * n3] + + outputList = subjectPolygon + cp1 = clipPolygon[-1] + + for clipVertex in clipPolygon: + cp2 = clipVertex + inputList = outputList + outputList = [] + s = inputList[-1] + + for subjectVertex in inputList: + e = subjectVertex + if inside(e): + if not inside(s): outputList.append(computeIntersection()) + outputList.append(e) + elif inside(s): outputList.append(computeIntersection()) + s = e + cp1 = cp2 + if len(outputList) == 0: return None + return (outputList) + +def convex_hull_intersection(p1, p2): + """ Compute area of two convex hull's intersection area. + p1,p2 are a list of (x,y) tuples of hull vertices. + return a list of (x,y) for the intersection and its volume + """ + inter_p = polygon_clip(p1,p2) + if inter_p is not None: + hull_inter = ConvexHull(inter_p) + return inter_p, hull_inter.volume + else: + return None, 0.0 + +def compute_inter_2D(boxa_bottom, boxb_bottom): + # computer intersection over union of two sets of bottom corner points + + _, I_2D = convex_hull_intersection(boxa_bottom, boxb_bottom) + + # a slower version + # from shapely.geometry import Polygon + # reca, recb = Polygon(boxa_bottom), Polygon(boxb_bottom) + # I_2D = reca.intersection(recb).area + + return I_2D + +def compute_height(box_a, box_b, inter=True): + + corners1 = Box3D.box2corners3d_camcoord(box_a) # 8 x 3 + corners2 = Box3D.box2corners3d_camcoord(box_b) # 8 x 3 + + if inter: # compute overlap height + ymax = min(corners1[0, 1], corners2[0, 1]) + ymin = max(corners1[4, 1], corners2[4, 1]) + height = max(0.0, ymax - ymin) + else: # compute union height + ymax = max(corners1[0, 1], corners2[0, 1]) + ymin = min(corners1[4, 1], corners2[4, 1]) + height = max(0.0, ymax - ymin) + + return height + +def compute_bottom(box_a, box_b): + # obtain ground corners and area, not containing the height + + corners1 = Box3D.box2corners3d_camcoord(box_a) # 8 x 3 + corners2 = Box3D.box2corners3d_camcoord(box_b) # 8 x 3 + + # get bottom corners and inverse order so that they are in the + # counter-clockwise order to fulfill polygon_clip + boxa_bot = corners1[-5::-1, [0, 2]] # 4 x 2 + boxb_bot = corners2[-5::-1, [0, 2]] # 4 x 2 + + return boxa_bot, boxb_bot + +def PolyArea2D(pts): + roll_pts = np.roll(pts, -1, axis=0) + area = np.abs(np.sum((pts[:, 0] * roll_pts[:, 1] - pts[:, 1] * roll_pts[:, 0]))) * 0.5 + return area + +def convex_area(boxa_bottom, boxb_bottom): + + # compute the convex area + all_corners = np.vstack((boxa_bottom, boxb_bottom)) + C = ConvexHull(all_corners) + convex_corners = all_corners[C.vertices] + convex_area = PolyArea2D(convex_corners) + + return convex_area + +#################### distance metric + +def iou(box_a, box_b, metric='giou_3d'): + ''' Compute 3D/2D bounding box IoU, only working for object parallel to ground + + Input: + Box3D instances + Output: + iou_3d: 3D bounding box IoU + iou_2d: bird's eye view 2D bounding box IoU + + box corner order is like follows + 1 -------- 0 top is bottom because y direction is negative + /| /| + 2 -------- 3 . + | | | | + . 5 -------- 4 + |/ |/ + 6 -------- 7 + + rect/ref camera coord: + right x, down y, front z + ''' + + # compute 2D related measures + boxa_bot, boxb_bot = compute_bottom(box_a, box_b) + I_2D = compute_inter_2D(boxa_bot, boxb_bot) + + # only needed for GIoU + if 'giou' in metric: + C_2D = convex_area(boxa_bot, boxb_bot) + + if '2d' in metric: # return 2D IoU/GIoU + U_2D = box_a.w * box_a.l + box_b.w * box_b.l - I_2D + if metric == 'iou_2d': return I_2D / U_2D + if metric == 'giou_2d': return I_2D / U_2D - (C_2D - U_2D) / C_2D + + elif '3d' in metric: # return 3D IoU/GIoU + overlap_height = compute_height(box_a, box_b) + I_3D = I_2D * overlap_height + U_3D = box_a.w * box_a.l * box_a.h + box_b.w * box_b.l * box_b.h - I_3D + if metric == 'iou_3d': return I_3D / U_3D + if metric == 'giou_3d': + union_height = compute_height(box_a, box_b, inter=False) + C_3D = C_2D * union_height + return I_3D / U_3D - (C_3D - U_3D) / C_3D + else: + assert False, '%s is not supported' % space + +def dist_ground(bbox1, bbox2): + # Compute distance of bottom center in 3D space, NOT considering the difference in height + + c1 = Box3D.bbox2array(bbox1)[[0, 2]] + c2 = Box3D.bbox2array(bbox2)[[0, 2]] + dist = np.linalg.norm(c1 - c2) + + return dist + +def dist3d_bottom(bbox1, bbox2): + # Compute distance of bottom center in 3D space, considering the difference in height / 2 + + c1 = Box3D.bbox2array(bbox1)[:3] + c2 = Box3D.bbox2array(bbox2)[:3] + dist = np.linalg.norm(c1 - c2) + + return dist + +def dist3d(bbox1, bbox2): + # Compute distance of actual center in 3D space, considering the difference in height + + corners1 = Box3D.box2corners3d_camcoord(bbox1) # 8 x 3 + corners2 = Box3D.box2corners3d_camcoord(bbox2) # 8 x 3 + + # compute center point based on 8 corners + c1 = np.average(corners1, axis=0) + c2 = np.average(corners2, axis=0) + + dist = np.linalg.norm(c1 - c2) + + return dist + +def diff_orientation_correction(diff): + """ + return the angle diff = det - trk + if angle diff > 90 or < -90, rotate trk and update the angle diff + """ + if diff > np.pi / 2: diff -= np.pi + if diff < -np.pi / 2: diff += np.pi + return diff + +def m_distance(det, trk, trk_inv_innovation_matrix=None): + + # compute difference + det_array = Box3D.bbox2array(det)[:7] + trk_array = Box3D.bbox2array(trk)[:7] # (7, ) + diff = np.expand_dims(det_array - trk_array, axis=1) # 7 x 1 + + # correct orientation + corrected_yaw_diff = diff_orientation_correction(diff[3]) + diff[3] = corrected_yaw_diff + + if trk_inv_innovation_matrix is not None: + dist = np.sqrt(np.matmul(np.matmul(diff.T, trk_inv_innovation_matrix), diff)[0][0]) + else: + dist = np.sqrt(np.dot(diff.T, diff)) # distance along 7 dimension + return dist \ No newline at end of file diff --git a/v2x/AB3DMOT_plugin/AB3DMOT_libs/io.py b/v2x/AB3DMOT_plugin/AB3DMOT_libs/io.py new file mode 100755 index 0000000..04fc10b --- /dev/null +++ b/v2x/AB3DMOT_plugin/AB3DMOT_libs/io.py @@ -0,0 +1,183 @@ +# Author: Xinshuo Weng +# email: xinshuo.weng@gmail.com + +import warnings, numpy as np, os +from xinshuo_io import mkdir_if_missing, load_txt_file, save_txt_file + + +################## loading + +def load_detection(file,cat): + # load from raw file + type_str2id = {'Trafficcone': 0, 'Pedestrian': 1, 'Car': 2, 'Cyclist': 3, 'Van': 4, 'Truck': 5, 'Bus': 6, + 'Tricyclist': 7, 'Motorcyclist': 8, 'Barrowlist': 9} + + try: + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + # dets = np.loadtxt(file, delimiter=' ') # load detections, N x 25 + list_data = [] + with open(file, 'r') as read_f: + list_lines = read_f.readlines() + if len(list_lines) == 0: + return [], False + for line in list_lines: + line = line.strip('\n').split(' ') + if line[1] == cat: + line[1] = type_str2id[line[1]] + line = [float(i) for i in line] + list_data.append(np.array(line)) + dets = np.array(list_data) + # print(dets) + + if len(dets.shape) == 1: + dets = np.expand_dims(dets, axis=0) + if dets.shape[1] == 0: # if no detection in a sequence + return [], False + else: + return dets, True + except: + print('cur seq dtc file not exsit!!!') + return [], False + +def get_frame_det(dets_all, frame): + # get irrelevant information associated with an object, not used for associationg + ori_array = dets_all[dets_all[:, 0] == frame, 5].reshape((-1, 1)) # alpha + type_array = dets_all[dets_all[:, 0] == frame, 1].reshape((-1, 1)) # type + bbox_array = dets_all[dets_all[:, 0] == frame, 6:10] # 2d bbox + score_array = dets_all[dets_all[:, 0] == frame, 22].reshape((-1, 1)) # det score + # other_array = dets_all[dets_all[:, 0] == frame, 1:7] # other information, e.g, 2D box, ... + # alpha type x1 y1 x2 y2 det_score + additional_info = np.concatenate((ori_array, type_array, bbox_array, score_array), axis=1) + + # get 3D camera box h w l cam_x cam_y cam_z ry + dets = dets_all[dets_all[:, 0] == frame, 10:17] + + # get 3D lidar box x y z rz + lidar_info = dets_all[dets_all[:, 0] == frame, 17:21] + dets_frame = {'dets': dets, 'info': additional_info, 'lidar_xyzr': lidar_info} + return dets_frame + + +def load_highlight(file): + # load file with each line containing seq_id, frame_id, ID, error_type + # used to highlight errors in the video visualization, such as IDS, FP + # but cannot be used to highlight FRAG (next frame) and FN now + + highlight, _ = load_txt_file(file) + data_dict = dict() + for data_tmp in highlight: + + # parse data in each line, seq_id, frame_id, ID, error_type + seq_id, frame_id, id_tmp, err_type = data_tmp.split(', ') + seq_id, frame_id, id_tmp = int(seq_id), int(frame_id), int(id_tmp) + + # create entry in the dictionary, with key -> seq, + # val -> dict{key -> frame, value -> dict{key -> ID, value -> err}} + if seq_id not in data_dict.keys(): + data_dict[seq_id] = dict() + if frame_id not in data_dict[seq_id]: + data_dict[seq_id][frame_id] = dict() + assert id_tmp not in data_dict[seq_id][frame_id], 'error, each ID should not be highlighted twice' + + # assign the err_type to the ID + data_dict[seq_id][frame_id][id_tmp] = err_type + + return data_dict + + +#################### saving + +def get_saving_dir(eval_dir_dict, seq_name, save_dir, num_hypo): + # create dir and file for saving + eval_file_dict, save_trk_dir = dict(), dict() + for index in range(num_hypo): + eval_file_dict[index] = os.path.join(eval_dir_dict[index], seq_name + '.txt') + eval_file_dict[index] = open(eval_file_dict[index], 'w') + save_trk_dir[index] = os.path.join(save_dir, 'trk_withid_%d' % index, seq_name) + # ./results/KITTI/pointrcnn_Car_val_H1/trk_withid_0/0000 + mkdir_if_missing(save_trk_dir[index]) + affinity_dir = os.path.join(save_dir, 'affi', seq_name) + # ./results/KITTI/pointrcnn_Car_val_H1/affi/0000 + mkdir_if_missing(affinity_dir) + affinity_vis = os.path.join(save_dir, 'affi_vis', seq_name) + # ./results/KITTI/pointrcnn_Car_val_H1/affi_vis/0000 + mkdir_if_missing(affinity_vis) + + return eval_file_dict, save_trk_dir, affinity_dir, affinity_vis + + +def save_results(res, save_trk_file, eval_file, frame, score_threshold): + type_id2str = {0: 'Trafficcone', 1: 'Pedestrian', 2: 'Car', 3: 'Cyclist', 4: 'Van', 5: 'Truck', 6: 'Bus', + 7: 'Tricyclist', 8: 'Motorcyclist', 9: 'Barrowlist'} + # box3d in the format of h, w, l, x, y, z, theta in camera coordinate + bbox3d_tmp, id_tmp, ori_tmp, type_tmp, bbox2d_tmp_trk, conf_tmp, lidar_xyzr = \ + res[0:7], res[7], res[8], type_id2str[int(res[9])], res[10:14], res[14], res[15:19] + + # save in detection format with track ID, can be used for dection evaluation and tracking visualization + str_to_srite = '%s -1 -1 %f %f %f %f %f %f %f %f %f %f %f %f %f %d\n' % (type_tmp, ori_tmp, + bbox2d_tmp_trk[0], bbox2d_tmp_trk[1], bbox2d_tmp_trk[2], + bbox2d_tmp_trk[3], + bbox3d_tmp[0], bbox3d_tmp[1], bbox3d_tmp[2], bbox3d_tmp[3], + bbox3d_tmp[4], bbox3d_tmp[5], bbox3d_tmp[6], conf_tmp, id_tmp) + save_trk_file.write(str_to_srite) + + # save in tracking format, for 3D MOT evaluation + if conf_tmp >= score_threshold: + # str_to_srite = '%s %d %s 0 0 %f %f %f %f %f %f %f %f %f %f %f %f %f\n' % (frame, id_tmp, + # type_tmp, ori_tmp, bbox2d_tmp_trk[0], bbox2d_tmp_trk[1], + # bbox2d_tmp_trk[2], bbox2d_tmp_trk[3], + # bbox3d_tmp[0], bbox3d_tmp[1], bbox3d_tmp[2], + # bbox3d_tmp[3], bbox3d_tmp[4], bbox3d_tmp[5], + # bbox3d_tmp[6], conf_tmp) + str_to_srite = '%06d %s %d 0 0 %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f -1 -1 %f -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1\n' % ( + int(frame), type_tmp, id_tmp, ori_tmp, bbox2d_tmp_trk[0], bbox2d_tmp_trk[1], bbox2d_tmp_trk[2], bbox2d_tmp_trk[3], bbox3d_tmp[0], + bbox3d_tmp[1], bbox3d_tmp[2], bbox3d_tmp[3], bbox3d_tmp[4], bbox3d_tmp[5], bbox3d_tmp[6], lidar_xyzr[0],lidar_xyzr[1],lidar_xyzr[2],lidar_xyzr[3], conf_tmp) + eval_file.write(str_to_srite) + + +def save_affinity(affi_data, save_path): + ######### save txt files for faster check, with aligned formatting + + # compute the number of digit for the largest values for better alignment of saving + min_val, max_val = np.min(affi_data), np.max(affi_data) + biggest = max(abs(min_val), abs(max_val)) + num_digit = 0 + while True: + if biggest < 1: break + num_digit += 1 + biggest = biggest / 10.0 + + # see if there is a negative sign, so need to a one more digit + negative = False + if min_val < 0: negative = True + if negative: num_digit += 1 + + # add digits depending on the decimals we want to preserve + decimals = 2 + num_digit += decimals + 1 # meaning that we want to preserve the dot plus the decimals + + # save + fmt = '%%%d.%df' % (num_digit, decimals) + np.savetxt(save_path, affi_data, fmt=fmt, delimiter=', ') + + +def combine_files(file_list, save_path, sort=True): + # combine txt files and sort them in frame order, used to collect results from + # different class categories + + # collect all files + data_all = list() + for file_tmp in file_list: + try: + data, num_lines = load_txt_file(file_tmp) + data_all += data + except: + print('file_tmp not exist: ',file_tmp ) + + + # sort based on frame number + if sort: + data_all.sort(key=lambda x: int(x.split(' ')[0])) + + save_txt_file(data_all, save_path) diff --git a/v2x/AB3DMOT_plugin/AB3DMOT_libs/kalman_filter.py b/v2x/AB3DMOT_plugin/AB3DMOT_libs/kalman_filter.py new file mode 100755 index 0000000..16fd509 --- /dev/null +++ b/v2x/AB3DMOT_plugin/AB3DMOT_libs/kalman_filter.py @@ -0,0 +1,66 @@ +import numpy as np +from filterpy.kalman import KalmanFilter, UnscentedKalmanFilter, MerweScaledSigmaPoints + +class Filter(object): + def __init__(self, bbox3D, info, ID, lidar_xyzr): + + self.initial_pos = bbox3D + self.time_since_update = 0 + self.id = ID + self.hits = 1 # number of total hits including the first detection + self.info = info # other information associated + self.lidar_xyzr = lidar_xyzr #lidar xyzr + +class KF(Filter): + def __init__(self, bbox3D, info, ID,lidar_xyzr): + super().__init__(bbox3D, info, ID, lidar_xyzr) + + self.kf = KalmanFilter(dim_x=10, dim_z=7) + # There is no need to use EKF here as the measurement and state are in the same space with linear relationship + + # state x dimension 10: x, y, z, theta, l, w, h, dx, dy, dz + # constant velocity model: x' = x + dx, y' = y + dy, z' = z + dz + # while all others (theta, l, w, h, dx, dy, dz) remain the same + self.kf.F = np.array([[1,0,0,0,0,0,0,1,0,0], # state transition matrix, dim_x * dim_x + [0,1,0,0,0,0,0,0,1,0], + [0,0,1,0,0,0,0,0,0,1], + [0,0,0,1,0,0,0,0,0,0], + [0,0,0,0,1,0,0,0,0,0], + [0,0,0,0,0,1,0,0,0,0], + [0,0,0,0,0,0,1,0,0,0], + [0,0,0,0,0,0,0,1,0,0], + [0,0,0,0,0,0,0,0,1,0], + [0,0,0,0,0,0,0,0,0,1]]) + + # measurement function, dim_z * dim_x, the first 7 dimensions of the measurement correspond to the state + self.kf.H = np.array([[1,0,0,0,0,0,0,0,0,0], + [0,1,0,0,0,0,0,0,0,0], + [0,0,1,0,0,0,0,0,0,0], + [0,0,0,1,0,0,0,0,0,0], + [0,0,0,0,1,0,0,0,0,0], + [0,0,0,0,0,1,0,0,0,0], + [0,0,0,0,0,0,1,0,0,0]]) + + # measurement uncertainty, uncomment if not super trust the measurement data due to detection noise + # self.kf.R[0:,0:] *= 10. + + # initial state uncertainty at time 0 + # Given a single data, the initial velocity is very uncertain, so giv a high uncertainty to start + self.kf.P[7:, 7:] *= 1000. + self.kf.P *= 10. + + # process uncertainty, make the constant velocity part more certain + self.kf.Q[7:, 7:] *= 0.01 + + # initialize data + self.kf.x[:7] = self.initial_pos.reshape((7, 1)) + + def compute_innovation_matrix(self): + """ compute the innovation matrix for association with mahalanobis distance + """ + return np.matmul(np.matmul(self.kf.H, self.kf.P), self.kf.H.T) + self.kf.R + + def get_velocity(self): + # return the object velocity in the state + + return self.kf.x[7:] \ No newline at end of file diff --git a/v2x/AB3DMOT_plugin/AB3DMOT_libs/kitti_oxts.py b/v2x/AB3DMOT_plugin/AB3DMOT_libs/kitti_oxts.py new file mode 100755 index 0000000..5010ac6 --- /dev/null +++ b/v2x/AB3DMOT_plugin/AB3DMOT_libs/kitti_oxts.py @@ -0,0 +1,185 @@ +import numpy as np, json +from numba import jit +from xinshuo_io import fileparts + +@jit +def rotx(t): + """Rotation about the x-axis.""" + c = np.cos(t) + s = np.sin(t) + return np.array([[1, 0, 0], + [0, c, -s], + [0, s, c]]) + +@jit +def roty(t): + """Rotation about the y-axis.""" + c = np.cos(t) + s = np.sin(t) + return np.array([[c, 0, s], + [0, 1, 0], + [-s, 0, c]]) + +@jit +def rotz(t): + """Rotation about the z-axis.""" + c = np.cos(t) + s = np.sin(t) + return np.array([[c, -s, 0], + [s, c, 0], + [0, 0, 1]]) + +@jit +def transform_from_rot_trans(R, t): + """Transforation matrix from rotation matrix and translation vector.""" + R = R.reshape(3, 3) + t = t.reshape(3, 1) + return np.vstack((np.hstack([R, t]), [0, 0, 0, 1])) + +@jit +def _poses_from_oxts(oxts_packets): + + """Helper method to compute SE(3) pose matrices from OXTS packets.""" + # https://github.com/pratikac/kitti/blob/master/pykitti/raw.py + + er = 6378137. # earth radius (approx.) in meters + + # compute scale from first lat value + scale = np.cos(oxts_packets[0].lat * np.pi / 180.) + + t_0 = [] # initial position + poses = [] # list of poses computed from oxts + for packet in oxts_packets: + # Use a Mercator projection to get the translation vector + tx = scale * packet.lon * np.pi * er / 180. + ty = scale * er * \ + np.log(np.tan((90. + packet.lat) * np.pi / 360.)) + tz = packet.alt + t = np.array([tx, ty, tz]) + + # We want the initial position to be the origin, but keep the ENU + # coordinate system + if len(t_0) == 0: + t_0 = t + + # Use the Euler angles to get the rotation matrix + Rx = rotx(packet.roll) + Ry = roty(packet.pitch) + Rz = rotz(packet.yaw) + R = Rz.dot(Ry.dot(Rx)) + + # Combine the translation and rotation into a homogeneous transform + poses.append(transform_from_rot_trans(R, t - t_0)) # store transformation matrix + + return np.stack(poses) + +def load_oxts(oxts_file): + """Load OXTS data from file.""" + # https://github.com/pratikac/kitti/blob/master/pykitti/raw.py + + ext = fileparts(oxts_file)[-1] + if ext == '.json': # loading for nuScenes-to-KITTI data + with open(oxts_file, 'r') as file: + imu_poses = json.load(file) + imu_poses = np.array(imu_poses) + + return imu_poses + + # Extract the data from each OXTS packe per dataformat.txt + from collections import namedtuple + OxtsPacket = namedtuple('OxtsPacket', + 'lat, lon, alt, ' + + 'roll, pitch, yaw, ' + + 'vn, ve, vf, vl, vu, ' + + 'ax, ay, az, af, al, au, ' + + 'wx, wy, wz, wf, wl, wu, ' + + 'pos_accuracy, vel_accuracy, ' + + 'navstat, numsats, ' + + 'posmode, velmode, orimode') + + oxts_packets = [] + with open(oxts_file, 'r') as f: + for line in f.readlines(): + line = line.split() + # Last five entries are flags and counts + line[:-5] = [float(x) for x in line[:-5]] + line[-5:] = [int(float(x)) for x in line[-5:]] + + data = OxtsPacket(*line) + oxts_packets.append(data) + + # Precompute the IMU poses in the world frame + imu_poses = _poses_from_oxts(oxts_packets) # seq_frames x 4 x 4 + + return imu_poses + +def get_ego_traj(imu_poses, frame, pref, futf, inverse=False, only_fut=False): + # compute the motion of the ego vehicle for ego-motion compensation + # using the current frame as the coordinate + # current frame means one frame prior to future, and also the last frame of the past + + # compute the start and end frame to retrieve the imu poses + num_frames = imu_poses.shape[0] + assert frame >= 0 and frame <= num_frames - 1, 'error' + if inverse: # pre and fut are inverse, i.e., inverse ego motion compensation + start = min(frame+pref-1, num_frames-1) + end = max(frame-futf-1, -1) + index = [*range(start, end, -1)] + else: + start = max(frame-pref+1, 0) + end = min(frame+futf+1, num_frames) + index = [*range(start, end)] + + # compute frame offset due to sequence boundary + left = start - (frame-pref+1) + right = (frame+futf+1) - end + + # compute relative transition compared to the current frame of the ego + all_world_xyz = imu_poses[index, :3, 3] # N x 3, only translation, frame = 10-19 for fut only (0-19 for all) + cur_world_xyz = imu_poses[frame] # 4 x 4, frame = 9 + T_world2imu = np.linalg.inv(cur_world_xyz) + all_world_hom = np.concatenate((all_world_xyz, np.ones((all_world_xyz.shape[0], 1))), axis=1) # N x 4 + all_xyz = all_world_hom.dot(T_world2imu.T)[:, :3] # N x 3 + + # compute relative rotation compared to the current frame of the ego + all_world_rot = imu_poses[index, :3, :3] # N x 3 x 3, only rotation + cur_world_rot = imu_poses[frame, :3, :3] # 3 x 3, frame = 9 + T_world2imu_rot = np.linalg.inv(cur_world_rot) + all_rot_list = list() + for frame in range(all_world_rot.shape[0]): + all_rot_tmp = all_world_rot[frame].dot(T_world2imu_rot) # 3 x 3 + all_rot_list.append(all_rot_tmp) + + if only_fut: + fut_xyz, fut_rot_list = all_xyz[pref-left:], all_rot_list[pref-left:] + return fut_xyz, fut_rot_list, left, right + else: + return all_xyz, all_rot_list, left, right + +def egomotion_compensation_ID(traj_id, calib, ego_rot_imu, ego_xyz_imu, left, right, mask=None): + # traj_id # N x 3 + # ego_imu can have frames less than pre+fut due to sequence boundary + + # convert trajectory data from rect to IMU for ego-motion compensation + traj_id_imu = calib.rect_to_imu(traj_id) # less_pre x 3 + + if mask is not None: + good_index = np.where(mask == 1)[0] + good_index = (good_index - left).tolist() + ego_rot_imu = np.array(ego_rot_imu) + ego_rot_imu = ego_rot_imu[good_index, :].tolist() + + # correct rotation + for frame in range(traj_id_imu.shape[0]): + traj_id_imu[frame, :] = np.matmul(ego_rot_imu[frame], traj_id_imu[frame, :].reshape((3, 1))).reshape((3, )) + + # correct transition + if mask is not None: + traj_id_imu += ego_xyz_imu[good_index, :] # les_frames x 3, TODO, need to test which is correct + else: + traj_id_imu += ego_xyz_imu[:traj_id_imu.shape[0], :] # les_frames x 3 + + # convert trajectory data back to rect coordinate for visualization + traj_id_rect = calib.imu_to_rect(traj_id_imu) + + return traj_id_rect \ No newline at end of file diff --git a/v2x/AB3DMOT_plugin/AB3DMOT_libs/matching.py b/v2x/AB3DMOT_plugin/AB3DMOT_libs/matching.py new file mode 100755 index 0000000..d088ce0 --- /dev/null +++ b/v2x/AB3DMOT_plugin/AB3DMOT_libs/matching.py @@ -0,0 +1,122 @@ +import numpy as np +from numba import jit +from scipy.optimize import linear_sum_assignment +from AB3DMOT_libs.dist_metrics import iou, dist3d, dist_ground, m_distance + +def compute_affinity(dets, trks, metric, trk_inv_inn_matrices=None): + # compute affinity matrix + + aff_matrix = np.zeros((len(dets), len(trks)), dtype=np.float32) + for d, det in enumerate(dets): + for t, trk in enumerate(trks): + try: + # choose to use different distance metrics + if 'iou' in metric: dist_now = iou(det, trk, metric) + elif metric == 'm_dis': dist_now = -m_distance(det, trk, trk_inv_inn_matrices[t]) + elif metric == 'euler': dist_now = -m_distance(det, trk, None) + elif metric == 'dist_2d': dist_now = -dist_ground(det, trk) + elif metric == 'dist_3d': dist_now = -dist3d(det, trk) + else: assert False, 'error' + except: + print('cal iou error!!!!!!!') + + if metric in ['giou_2d', 'giou_3d']: dist_now = -1.0 + elif metric in ['iou_2d', 'iou_3d']: dist_now = 0.0 + elif metric in ['dist_3d', 'dist_2d', 'm_dis']: dist_now = -100 + else: assert False, 'error' + + aff_matrix[d, t] = dist_now + + return aff_matrix + +def greedy_matching(cost_matrix): + # association in the greedy manner + # refer to https://github.com/eddyhkchiu/mahalanobis_3d_multi_object_tracking/blob/master/main.py + + num_dets, num_trks = cost_matrix.shape[0], cost_matrix.shape[1] + + # sort all costs and then convert to 2D + distance_1d = cost_matrix.reshape(-1) + index_1d = np.argsort(distance_1d) + index_2d = np.stack([index_1d // num_trks, index_1d % num_trks], axis=1) + + # assign matches one by one given the sorting, but first come first serves + det_matches_to_trk = [-1] * num_dets + trk_matches_to_det = [-1] * num_trks + matched_indices = [] + for sort_i in range(index_2d.shape[0]): + det_id = int(index_2d[sort_i][0]) + trk_id = int(index_2d[sort_i][1]) + + # if both id has not been matched yet + if trk_matches_to_det[trk_id] == -1 and det_matches_to_trk[det_id] == -1: + trk_matches_to_det[trk_id] = det_id + det_matches_to_trk[det_id] = trk_id + matched_indices.append([det_id, trk_id]) + + return np.asarray(matched_indices) + +def data_association(dets, trks, metric, threshold, algm='greedy', \ + trk_innovation_matrix=None, hypothesis=1): + """ + Assigns detections to tracked object + + dets: a list of Box3D object + trks: a list of Box3D object + + Returns 3 lists of matches, unmatched_dets and unmatched_trks, and total cost, and affinity matrix + """ + + # if there is no item in either row/col, skip the association and return all as unmatched + aff_matrix = np.zeros((len(dets), len(trks)), dtype=np.float32) + if len(trks) == 0: + return np.empty((0, 2), dtype=int), np.arange(len(dets)), [], 0, aff_matrix + if len(dets) == 0: + return np.empty((0, 2), dtype=int), [], np.arange(len(trks)), 0, aff_matrix + + # prepare inverse innovation matrix for m_dis + if metric == 'm_dis': + assert trk_innovation_matrix is not None, 'error' + trk_inv_inn_matrices = [np.linalg.inv(m) for m in trk_innovation_matrix] + else: + trk_inv_inn_matrices = None + + # compute affinity matrix + aff_matrix = compute_affinity(dets, trks, metric, trk_inv_inn_matrices) + + # association based on the affinity matrix + if hypothesis == 1: + if algm == 'hungar': + row_ind, col_ind = linear_sum_assignment(-aff_matrix) # hougarian algorithm + matched_indices = np.stack((row_ind, col_ind), axis=1) + elif algm == 'greedy': + matched_indices = greedy_matching(-aff_matrix) # greedy matching + else: assert False, 'error' + else: + cost_list, hun_list = best_k_matching(-aff_matrix, hypothesis) + + # compute total cost + cost = 0 + for row_index in range(matched_indices.shape[0]): + cost -= aff_matrix[matched_indices[row_index, 0], matched_indices[row_index, 1]] + + # save for unmatched objects + unmatched_dets = [] + for d, det in enumerate(dets): + if (d not in matched_indices[:, 0]): unmatched_dets.append(d) + unmatched_trks = [] + for t, trk in enumerate(trks): + if (t not in matched_indices[:, 1]): unmatched_trks.append(t) + + # filter out matches with low affinity + matches = [] + for m in matched_indices: + if (aff_matrix[m[0], m[1]] < threshold): + unmatched_dets.append(m[0]) + unmatched_trks.append(m[1]) + else: matches.append(m.reshape(1, 2)) + if len(matches) == 0: + matches = np.empty((0, 2),dtype=int) + else: matches = np.concatenate(matches, axis=0) + + return matches, np.array(unmatched_dets), np.array(unmatched_trks), cost, aff_matrix \ No newline at end of file diff --git a/v2x/AB3DMOT_plugin/AB3DMOT_libs/model.py b/v2x/AB3DMOT_plugin/AB3DMOT_libs/model.py new file mode 100755 index 0000000..2679319 --- /dev/null +++ b/v2x/AB3DMOT_plugin/AB3DMOT_libs/model.py @@ -0,0 +1,241 @@ +# Author: Xinshuo Weng +# email: xinshuo.weng@gmail.com + +import numpy as np, os, copy, math +from AB3DMOT_libs.box import Box3D +from AB3DMOT_libs.matching import data_association +from AB3DMOT_libs.kalman_filter import KF +from AB3DMOT_libs.vis import vis_obj +from xinshuo_miscellaneous import print_log +from xinshuo_io import mkdir_if_missing + +from AB3DMOT.AB3DMOT_libs.model import AB3DMOT + +np.set_printoptions(suppress=True, precision=3) + + +# A Baseline of 3D Multi-Object Tracking +class AB3DMOT_custom(AB3DMOT): + def __init__(self, cfg, cat, calib=None, oxts=None, img_dir=None, vis_dir=None, hw=None, log=None, ID_init=0): + super().__init__(cfg, cat, calib, oxts, img_dir, vis_dir, hw, log, ID_init) + + def get_param(self, cfg, cat): + # get parameters for each dataset + + if cfg.dataset == 'KITTI': + if cfg.det_name == 'pvrcnn': # tuned for PV-RCNN detections + if cat == 'Car': + algm, metric, thres, min_hits, max_age = 'hungar', 'giou_3d', -0.2, 3, 2 + elif cat == 'Pedestrian': + algm, metric, thres, min_hits, max_age = 'greedy', 'giou_3d', -0.4, 1, 4 + elif cat == 'Cyclist': + algm, metric, thres, min_hits, max_age = 'hungar', 'dist_3d', 2, 3, 4 + else: + assert False, 'error' + elif cfg.det_name == 'pointrcnn': # tuned for PointRCNN detections + if cat == 'Car': + # algm, metric, thres, min_hits, max_age = 'hungar', 'giou_3d', -0.2, 3, 2 + algm, metric, thres, min_hits, max_age = 'hungar', 'giou_3d', -0.2, 1, 21 + elif cat == 'Pedestrian': + algm, metric, thres, min_hits, max_age = 'greedy', 'giou_3d', -0.4, 1, 4 + elif cat == 'Cyclist': + algm, metric, thres, min_hits, max_age = 'hungar', 'dist_3d', 2, 3, 4 + else: + assert False, 'error' + elif cfg.det_name == 'deprecated': + if cat == 'Car': + algm, metric, thres, min_hits, max_age = 'hungar', 'dist_3d', 6, 3, 2 + elif cat == 'Pedestrian': + algm, metric, thres, min_hits, max_age = 'hungar', 'dist_3d', 1, 3, 2 + elif cat == 'Cyclist': + algm, metric, thres, min_hits, max_age = 'hungar', 'dist_3d', 6, 3, 2 + else: + assert False, 'error' + else: + if cat == 'Car': algm, metric, thres, min_hits, max_age = 'hungar', 'giou_3d', -0.2, 3, 2 + elif cat == 'Pedestrian': algm, metric, thres, min_hits, max_age = 'greedy', 'giou_3d', -0.4, 1, 4 + elif cat == 'Cyclist': algm, metric, thres, min_hits, max_age = 'hungar', 'dist_3d', 2, 3, 4 + else: assert False, 'error' + else: + assert False, 'no such dataset' + + # add negative due to it is the cost + if metric in ['dist_3d', 'dist_2d', 'm_dis']: thres *= -1 + self.algm, self.metric, self.thres, self.max_age, self.min_hits = \ + algm, metric, thres, max_age, min_hits + + # define max/min values for the output affinity matrix + if self.metric in ['dist_3d', 'dist_2d', 'm_dis']: + self.max_sim, self.min_sim = 0.0, -100. + elif self.metric in ['iou_2d', 'iou_3d']: + self.max_sim, self.min_sim = 1.0, 0.0 + elif self.metric in ['giou_2d', 'giou_3d']: + self.max_sim, self.min_sim = 1.0, -1.0 + + def update(self, matched, unmatched_trks, dets, info, lidar_xyzr): + # update matched trackers with assigned detections + + dets = copy.copy(dets) + for t, trk in enumerate(self.trackers): + if t not in unmatched_trks: + d = matched[np.where(matched[:, 1] == t)[0], 0] # a list of index + assert len(d) == 1, 'error' + + # update statistics + trk.time_since_update = 0 # reset because just updated + trk.hits += 1 + + # update orientation in propagated tracks and detected boxes so that they are within 90 degree + bbox3d = Box3D.bbox2array(dets[d[0]]) + trk.kf.x[3], bbox3d[3] = self.orientation_correction(trk.kf.x[3], bbox3d[3]) + + if trk.id == self.debug_id: + print('After ego-compoensation') + print(trk.kf.x.reshape((-1))) + print('matched measurement') + print(bbox3d.reshape((-1))) + # print('uncertainty') + # print(trk.kf.P) + # print('measurement noise') + # print(trk.kf.R) + + # kalman filter update with observation + trk.kf.update(bbox3d) + + if trk.id == self.debug_id: + print('after matching') + print(trk.kf.x.reshape((-1))) + print('\n current velocity') + print(trk.get_velocity()) + + trk.kf.x[3] = self.within_range(trk.kf.x[3]) + trk.info = info[d, :][0] + trk.lidar_xyzr = lidar_xyzr[d, :][0] + + # debug use only + # else: + # print('track ID %d is not matched' % trk.id) + + def birth(self, dets, info, unmatched_dets, lidar_xyzr): + # create and initialise new trackers for unmatched detections + + # dets = copy.copy(dets) + new_id_list = list() # new ID generated for unmatched detections + for i in unmatched_dets: # a scalar of index + trk = KF(Box3D.bbox2array(dets[i]), info[i, :], self.ID_count[0],lidar_xyzr[i,:]) + self.trackers.append(trk) + new_id_list.append(trk.id) + # print('track ID %s has been initialized due to new detection' % trk.id) + + self.ID_count[0] += 1 + + return new_id_list + + def output(self): + # output exiting tracks that have been stably associated, i.e., >= min_hits + # and also delete tracks that have appeared for a long time, i.e., >= max_age + + num_trks = len(self.trackers) + results = [] + for trk in reversed(self.trackers): + # change format from [x,y,z,theta,l,w,h] to [h,w,l,x,y,z,theta] + d = Box3D.array2bbox(trk.kf.x[:7].reshape((7,))) # bbox location self + d = Box3D.bbox2array_raw(d) + + if ((trk.time_since_update < 1) and (trk.hits >= self.min_hits)): + # if ((trk.time_since_update < self.max_age) and (trk.hits >= self.min_hits or self.frame_count <= self.min_hits)): + # if ((trk.time_since_update < self.max_age) and (trk.hits >= self.min_hits or self.frame_count <= self.min_hits)): + results.append(np.concatenate((d, [trk.id], trk.info, trk.lidar_xyzr)).reshape(1, -1)) + num_trks -= 1 + + # deadth, remove dead tracklet + if (trk.time_since_update >= self.max_age): + self.trackers.pop(num_trks) + + return results + + def track(self, dets_all, frame, seq_name): + """ + Params: + dets_all: dict + dets - a numpy array of detections in the format [[h,w,l,x,y,z,theta],...] + info: a array of other info for each det + lidar_xyzr: a array of lidar location and rotation z + frame: str, frame number, used to query ego pose + Requires: this method must be called once for each frame even with empty detections. + Returns the a similar array, where the last column is the object ID. + + NOTE: The number of objects returned may differ from the number of detections provided. + """ + dets, info, lidar_xyzr = dets_all['dets'], dets_all['info'], dets_all['lidar_xyzr'] # dets: N x 7, float numpy array + if self.debug_id: + print('\nframe is %s' % frame) + + # logging + print_str = '\n\n*****************************************\n\nprocessing seq_name/frame %s/%d' % (seq_name, frame) + print_log(print_str, log=self.log, display=False) + self.frame_count += 1 + + # recall the last frames of outputs for computing ID correspondences during affinity processing + self.id_past_output = copy.copy(self.id_now_output) + self.id_past = [trk.id for trk in self.trackers] + + # process detection format + dets = self.process_dets(dets) + + # tracks propagation based on velocity + trks = self.prediction() + + # ego motion compensation, adapt to the current frame of camera coordinate + # if (frame > 0) and (self.ego_com) and (self.oxts is not None): + # trks = self.ego_motion_compensation(frame, trks) + + # visualization + # if self.vis and (self.vis_dir is not None): + # img = os.path.join(self.img_dir, f'{frame:06d}.png') + # save_path = os.path.join(self.vis_dir, f'{frame:06d}.jpg'); mkdir_if_missing(save_path) + # self.visualization(img, dets, trks, self.calib, self.hw, save_path) + + # matching + trk_innovation_matrix = None + if self.metric == 'm_dis': + trk_innovation_matrix = [trk.compute_innovation_matrix() for trk in self.trackers] + matched, unmatched_dets, unmatched_trks, cost, affi = \ + data_association(dets, trks, self.metric, self.thres, self.algm, trk_innovation_matrix) + # print_log('detections are', log=self.log, display=False) + # print_log(dets, log=self.log, display=False) + # print_log('tracklets are', log=self.log, display=False) + # print_log(trks, log=self.log, display=False) + # print_log('matched indexes are', log=self.log, display=False) + # print_log(matched, log=self.log, display=False) + # print_log('raw affinity matrix is', log=self.log, display=False) + # print_log(affi, log=self.log, display=False) + + # update trks with matched detection measurement + self.update(matched, unmatched_trks, dets, info, lidar_xyzr) + + # create and initialise new trackers for unmatched detections + new_id_list = self.birth(dets, info, unmatched_dets, lidar_xyzr) + + # output existing valid tracks + results = self.output() + if len(results) > 0: + results = [np.concatenate(results)] # h,w,l,x,y,z,theta, ID, other info, confidence + else: + results = [np.empty((0, 19))]####ywx + self.id_now_output = results[0][:, 7].tolist() # only the active tracks that are outputed + + # post-processing affinity to convert to the affinity between resulting tracklets + if self.affi_process: + affi = self.process_affi(affi, matched, unmatched_dets, new_id_list) + # print_log('processed affinity matrix is', log=self.log, display=False) + # print_log(affi, log=self.log, display=False) + + # logging + print_log('\ntop-1 cost selected', log=self.log, display=False) + print_log(cost, log=self.log, display=False) + for result_index in range(len(results)): + print_log(results[result_index][:, :8], log=self.log, display=False) + print_log('', log=self.log, display=False) + + return results, affi diff --git a/v2x/AB3DMOT_plugin/AB3DMOT_libs/utils.py b/v2x/AB3DMOT_plugin/AB3DMOT_libs/utils.py new file mode 100755 index 0000000..31d1370 --- /dev/null +++ b/v2x/AB3DMOT_plugin/AB3DMOT_libs/utils.py @@ -0,0 +1,137 @@ +# Author: Xinshuo Weng +# email: xinshuo.weng@gmail.com + +import yaml, numpy as np, os +from easydict import EasyDict as edict + +# from AB3DMOT_libs.model_multi import AB3DMOT_multi + +# from AB3DMOT_libs.kitti_oxts import load_oxts +# from AB3DMOT_libs.kitti_calib import Calibration +# from AB3DMOT_libs.nuScenes_split import get_split +from xinshuo_io import mkdir_if_missing, is_path_exists, fileparts, load_list_from_folder +from xinshuo_miscellaneous import merge_listoflist +from AB3DMOT_libs.model import AB3DMOT_custom + + +def Config(filename): + listfile1 = open(filename, 'r') + listfile2 = open(filename, 'r') + cfg = edict(yaml.safe_load(listfile1)) + settings_show = listfile2.read().splitlines() + + listfile1.close() + listfile2.close() + + return cfg, settings_show + + +def get_subfolder_seq(dataset, split, split_data_path): + + + # dataset setting + file_path = os.path.dirname(os.path.realpath(__file__)) + + if dataset == 'KITTI': # KITTI + det_id2str = {0: 'Trafficcone', 1: 'Pedestrian', 2: 'Car', 3: 'Cyclist', 4: 'Van', 5: 'Truck', 6: 'Bus', + 7: 'Tricyclist', 8: 'Motorcyclist', 9: 'Barrowlist'} + + if split == 'val': + subfolder = 'validation' + elif split == 'test': + subfolder = 'testing' + else: + subfolder = 'training' + + hw = {'image': (1920, 1080), 'lidar': (720, 1920)} + + import json + with open(split_data_path,'r') as fp: + split_data = json.load(fp) + + seq_eval = split_data['batch_split'][split] + + data_root = os.path.join(file_path, '../../../data/V2X-Seq-SPD-KITTI') # path containing the KITTI root + + else: + assert False, 'error, %s dataset is not supported' % dataset + + return subfolder, det_id2str, hw, seq_eval, data_root + + +def get_threshold(dataset, det_name): + # used for visualization only as we want to remove some false positives, also can be + # used for KITTI 2D MOT evaluation which uses a single operating point + # obtained by observing the threshold achieving the highest MOTA on the validation set + + if dataset == 'KITTI': + # if det_name == 'pointrcnn': + if det_name: + return {'Car': 3.240738, 'Pedestrian': 2.683133, 'Cyclist': 3.645319} + else: + assert False, 'error, detection method not supported for getting threshold' % det_name + elif dataset == 'nuScenes': + if det_name == 'megvii': + return {'Car': 0.262545, 'Pedestrian': 0.217600, 'Truck': 0.294967, 'Trailer': 0.292775, + 'Bus': 0.440060, 'Motorcycle': 0.314693, 'Bicycle': 0.284720} + if det_name == 'centerpoint': + return {'Car': 0.269231, 'Pedestrian': 0.410000, 'Truck': 0.300000, 'Trailer': 0.372632, + 'Bus': 0.430000, 'Motorcycle': 0.368667, 'Bicycle': 0.394146} + else: + assert False, 'error, detection method not supported for getting threshold' % det_name + else: + assert False, 'error, dataset %s not supported for getting threshold' % dataset + + +def initialize(cfg, data_root, seq_dets, subfolder, seq_name, cat, ID_start, log_file): + # initiate the tracker + if cfg.num_hypo > 1: + # tracker = AB3DMOT_multi(cfg, cat, calib=None, oxts=None, img_dir=None, vis_dir=None, hw=None, log=log_file, + # ID_init=ID_start) + assert False, 'error' + elif cfg.num_hypo == 1: + tracker = AB3DMOT_custom(cfg, cat, calib=None, oxts=None, img_dir=None, vis_dir=None, hw=None, log=log_file, ID_init=ID_start) + else: + assert False, 'error' + + # compute the min/max frame + frame_list = list(seq_dets[:, 0]) + frame_list = list(set(frame_list)) + + return tracker, frame_list + + +def find_all_frames(root_dir, subset, data_suffix, seq_list): + # warm up to find union of all frames from results of all categories in all sequences + # finding the union is important because there might be some sequences with only cars while + # some other sequences only have pedestrians, so we may miss some results if mainly looking + # at one single category + # return a dictionary with each key correspondes to the list of frame ID + + # loop through every sequence + frame_dict = dict() + for seq_tmp in seq_list: + frame_all = list() + + # find all frame indexes for each category + for subset_tmp in subset: + data_dir = os.path.join(root_dir, subset_tmp, 'trk_withid' + data_suffix, seq_tmp) # pointrcnn_ped + if not is_path_exists(data_dir): + print('%s dir not exist' % data_dir) + # assert False, 'error' + continue + + # extract frame string from this category + frame_list, _ = load_list_from_folder(data_dir) + frame_list = [fileparts(frame_tmp)[1] for frame_tmp in frame_list] + frame_all.append(frame_list) + + # merge frame indexes from all categories + + try: + frame_all = merge_listoflist(frame_all, unique=True) + except: + frame_all = list() + frame_dict[seq_tmp] = frame_all + + return frame_dict diff --git a/v2x/AB3DMOT_plugin/AB3DMOT_libs/vis.py b/v2x/AB3DMOT_plugin/AB3DMOT_libs/vis.py new file mode 100755 index 0000000..07aa43e --- /dev/null +++ b/v2x/AB3DMOT_plugin/AB3DMOT_libs/vis.py @@ -0,0 +1,137 @@ +import numpy as np, cv2, random +from PIL import Image +from AB3DMOT_libs.box import Box3D +from xinshuo_visualization import random_colors + +random.seed(0) +max_color = 30 +colors = random_colors(max_color) # Generate random colors + +def draw_box3d_image(image, qs, img_size=(900, 1600), color=(255,255,255), thickness=4): + ''' Draw 3d bounding box in image + qs: (8,2) array of vertices for the 3d box in following order: + 1 -------- 0 + /| /| + 2 -------- 3 . + | | | | + . 5 -------- 4 + |/ |/ + 6 -------- 7 + ''' + + def check_outside_image(x, y, height, width): + if x < 0 or x >= width: return True + if y < 0 or y >= height: return True + + # if 6 points of the box are outside the image, then do not draw + pts_outside = 0 + for index in range(8): + check = check_outside_image(qs[index, 0], qs[index, 1], img_size[0], img_size[1]) + if check: pts_outside += 1 + if pts_outside >= 6: return image, False + + # actually draw + if qs is not None: + qs = qs.astype(np.int32) + for k in range(0,4): + i,j=k,(k+1)%4 + image = cv2.line(image, (qs[i,0],qs[i,1]), (qs[j,0],qs[j,1]), color, thickness, cv2.LINE_AA) # use LINE_AA for opencv3 + + i,j=k+4,(k+1)%4 + 4 + image = cv2.line(image, (qs[i,0],qs[i,1]), (qs[j,0],qs[j,1]), color, thickness, cv2.LINE_AA) + + i,j=k,k+4 + image = cv2.line(image, (qs[i,0],qs[i,1]), (qs[j,0],qs[j,1]), color, thickness, cv2.LINE_AA) + + return image, True + +def vis_obj(box, img, calib, hw, color_tmp=None, str_vis=None, thickness=4, id_hl=None, err_type=None): + # visualize an individual object + # repeat is for highlighted objects, used to create pause in the video + + # draw box + obj_8corner = Box3D.box2corners3d_camcoord(box) + obj_pts_2d = calib.project_rect_to_image(obj_8corner) + img, draw = draw_box3d_image(img, obj_pts_2d, hw, color=color_tmp, thickness=thickness) + + # draw text + if draw and obj_pts_2d is not None and str_vis is not None: + x1, y1 = int(obj_pts_2d[4, 0]), int(obj_pts_2d[4, 1]) + img = cv2.putText(img, str_vis, (x1+5, y1-10), cv2.FONT_HERSHEY_TRIPLEX, 0.5, color_tmp, int(thickness/2)) + + # highlight + if err_type is not None: + + # compute the radius of the highlight + xmin = np.min(obj_pts_2d[:, 0]); xmax = np.max(obj_pts_2d[:, 0]) + ymin = np.min(obj_pts_2d[:, 1]); ymax = np.max(obj_pts_2d[:, 1]) + radius = int(max(ymax - ymin, xmax - xmin) / 2 * 1.5) + radius = max(radius, 50) + + # draw highlighting circle + center = np.average(obj_pts_2d, axis=0) + center = tuple(center.astype('int16')) + img = cv2.circle(img, center, radius, (255, 0, 0), 4) + + # draw error message + pos_x, pos_y = center[0] - radius, center[1] - radius - 10 + font = cv2.FONT_HERSHEY_TRIPLEX + font_scale = 1 + font_thickness = 2 + text_size, _ = cv2.getTextSize(err_type, font, font_scale, font_thickness) + text_w, text_h = text_size + cv2.rectangle(img, (pos_x, pos_y - text_h - 5), (pos_x + text_w, pos_y + 5), (255, 255, 255), -1) # add white background + img = cv2.putText(img, err_type, (pos_x, pos_y), font, font_scale, (255, 0, 0), font_thickness) + + return img + +def vis_image_with_obj(img, obj_res, obj_gt, calib, hw, save_path, h_thres=0, \ + color_type='det', id_hl=None, repeat=60): + # obj_res, obj_gt, a list of object3D class instances + # h_thres: height threshold for filtering objects + # id_hl: ID to be highlighted, color_type: ['det', 'trk'], trk means different color for each one + # det means th same color for the same object + + # load image + img = np.array(Image.open(img)) + + # loop through every objects + for obj in obj_res: + depth = obj.z + if depth >= 2: # check in front of camera + + # obtain object color and thickness + if color_type == 'trk': + color_id = obj.id # vary across objects + thickness = 5 + elif color_type == 'det': + if id_hl is not None and obj.id in id_hl: + # color_id = 29 # fixed, red for highlighted errors + color_id = obj.id * 9 # some magic number to scale up the id so that nearby ID does not have similar color + thickness = 5 # highlighted objects are thicker + else: + color_id = 13 # general object, fixed, lightgreen + thickness = 1 # general objects are thin + color_tmp = tuple([int(tmp * 255) for tmp in colors[color_id % max_color]]) + + # get miscellaneous information + box_tmp = obj.get_box3D() + str_vis = 'ID: %d' % obj.id + + # retrieve index in the id_hl dict + if id_hl is not None and obj.id in id_hl: + err_type = id_hl[obj.id] + else: + err_type = None + img = vis_obj(box_tmp, img, calib, hw['image'], color_tmp, str_vis, thickness, id_hl, err_type) + + # save image + img = Image.fromarray(img) + img = img.resize((hw['image'][1], hw['image'][0])) + img.save(save_path) + + # create copy of the same image with highlighted objects to pause + if id_hl is not None: + for repeat_ in range(repeat): + save_path_tmp = save_path[:-4] + '_repeat_%d' % repeat_ + save_path[-4:] + img.save(save_path_tmp) \ No newline at end of file diff --git a/v2x/AB3DMOT_plugin/__init__.py b/v2x/AB3DMOT_plugin/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/v2x/AB3DMOT_plugin/configs/KITTI.yml b/v2x/AB3DMOT_plugin/configs/KITTI.yml new file mode 100755 index 0000000..220f886 --- /dev/null +++ b/v2x/AB3DMOT_plugin/configs/KITTI.yml @@ -0,0 +1,18 @@ +# ------------------- General Options ------------------------- +description : AB3DMOT +seed : 0 + +# --------------- main.py +save_root : ./results/KITTI +dataset : KITTI # KITTI +split : val # val, test +det_name : pointrcnn # name of the detector [pointrcnn, pvrcnn] +cat_list : ['Car'] #['Car', 'Pedestrian', 'Cyclist'] + +score_threshold : -10000 # filter out tracklet with low confidence if necessary, default no filtering here but do it in trk_conf_threshold.py +num_hypo : 1 # >1 to allow multi-hypothesis tracking + +# --------------- model.py +ego_com : false # turn on only slightly reduce speed but increase a lot for performance +vis : false # only for debug or visualization purpose, will significantly reduce speed +affi_pro : true \ No newline at end of file diff --git a/v2x/AB3DMOT_plugin/main_tracking.py b/v2x/AB3DMOT_plugin/main_tracking.py new file mode 100755 index 0000000..566f2a7 --- /dev/null +++ b/v2x/AB3DMOT_plugin/main_tracking.py @@ -0,0 +1,167 @@ +# Author: Xinshuo Weng +# email: xinshuo.weng@gmail.com + +from __future__ import print_function +import matplotlib; + +matplotlib.use('Agg') +import os, numpy as np, time, sys, argparse +from AB3DMOT_libs.io import load_detection, get_saving_dir, get_frame_det, save_results, save_affinity +from AB3DMOT_libs.utils import Config, get_subfolder_seq, initialize +from scripts.post_processing.combine_trk_cat import combine_trk_cat +from xinshuo_io import mkdir_if_missing, save_txt_file +from xinshuo_miscellaneous import get_timestring, print_log + +file_path = os.path.dirname(os.path.realpath(__file__)) +file_dir_path = os.path.dirname(file_path) + +def parse_args(): + parser = argparse.ArgumentParser(description='AB3DMOT') + parser.add_argument('--dataset', type=str, default='KITTI', help='KITTI, nuScenes') + parser.add_argument('--split', type=str, default='val', help='train, val, test') + parser.add_argument('--det_name', type=str, default='imvoxelnet', help='imvoxelnet') + parser.add_argument('--cat', type=str, default='Car', help='category of running tracking') + parser.add_argument('--split-data-path', type=str, default='../data/split_datas/cooperative-split-data-spd.json', help='split-data-path') + parser.add_argument("--input-path", type=str, default="") + parser.add_argument("--output-path", type=str, default="") + + args = parser.parse_args() + return args + + +def main_per_cat(cfg, cat, log, ID_start): + # get data-cat-split specific path + # file_path = os.path.dirname(os.path.realpath(__file__)) + result_sha = '%s_%s_%s' % (cfg.det_name, cat, cfg.split) # pointrcnn_Car_val + det_root = os.path.join(file_dir_path, cfg.input_path, result_sha) # './data/KITTI/detection/pointrcnn_Car_val' + + subfolder, _, hw, seq_eval, data_root = get_subfolder_seq(cfg.dataset, cfg.split, cfg.split_data_path) + + trk_root = os.path.join(data_root, 'tracking') # 'data/V2X-Seq-SPD-KITTI/tracking' + + save_dir = os.path.join(file_dir_path, cfg.output_path, result_sha + '_H%d' % cfg.num_hypo) + mkdir_if_missing(save_dir) + + # create eval dir for each hypothesis + eval_dir_dict = dict() + for index in range(cfg.num_hypo): + eval_dir_dict[index] = os.path.join(save_dir, 'data_%d' % index) # {0: './results/KITTI/pointrcnn_Car_val_H1/data_0'} + mkdir_if_missing(eval_dir_dict[index]) + + # loop every sequence + seq_count = 0 + total_time, total_frames = 0.0, 0 + for seq_name in seq_eval: + # print('cur seg name is : ',seq_name) + seq_file = os.path.join(det_root, seq_name + '.txt') # ./data/KITTI/detection/pointrcnn_Car_val/0000.txt + seq_dets, flag = load_detection(seq_file,cat) # load detection N x 25 + if not flag: + continue # no detection + + # create folders for saving + eval_file_dict, save_trk_dir, affinity_dir, affinity_vis = \ + get_saving_dir(eval_dir_dict, seq_name, save_dir, cfg.num_hypo) + + # initialize tracker + tracker, frame_list = initialize(cfg, trk_root, seq_dets, subfolder, seq_name, cat, ID_start, log) + frame_list.sort() + + # loop over frame + min_frame, max_frame = frame_list[0], frame_list[-1] + for frame in frame_list: + # add an additional frame here to deal with the case that the last frame, although no detection + # but should output an N x 0 affinity for consistency + + # logging + print_str = 'processing %s %s: %d/%d, %s/%s \r' % (result_sha, seq_name, seq_count, len(seq_eval), frame, max_frame) + sys.stdout.write(print_str) + sys.stdout.flush() + + # tracking by detection + dets_frame = get_frame_det(seq_dets, frame) + since = time.time() + results, affi = tracker.track(dets_frame, frame, seq_name) + total_time += time.time() - since + + # saving affinity matrix, between the past frame and current frame + # e.g., for 000006.npy, it means affinity between frame 5 and 6 + # note that the saved value in affinity can be different in reality because it is between the + # original detections and ego-motion compensated predicted tracklets, rather than between the + # actual two sets of output tracklets + save_affi_file = os.path.join(affinity_dir, '%06d.npy' % frame) + save_affi_vis = os.path.join(affinity_vis, '%06d.txt' % frame) + if (affi is not None) and (affi.shape[0] + affi.shape[1] > 0): + # save affinity as long as there are tracklets in at least one frame + np.save(save_affi_file, affi) + + # cannot save for visualization unless both two frames have tracklets + if affi.shape[0] > 0 and affi.shape[1] > 0: + save_affinity(affi, save_affi_vis) + + # saving trajectories, loop over each hypothesis + for hypo in range(cfg.num_hypo): + save_trk_file = os.path.join(save_trk_dir[hypo], '%06d.txt' % frame) + save_trk_file = open(save_trk_file, 'w') + for result_tmp in results[hypo]: # N x 15 + save_results(result_tmp, save_trk_file, eval_file_dict[hypo], frame, cfg.score_threshold) + save_trk_file.close() + + total_frames += 1 + seq_count += 1 + + for index in range(cfg.num_hypo): + eval_file_dict[index].close() + ID_start = max(ID_start, tracker.ID_count[index]) + + print_log('%s, %25s: %4.f seconds for %5d frames or %6.1f FPS, metric is %s = %.2f' % ( + cfg.dataset, result_sha, total_time, total_frames, total_frames / total_time, tracker.metric, tracker.thres), log=log) + + return ID_start + + +def tracking(args): + # load config files + config_path = 'configs/%s.yml' % args.dataset + config_path = os.path.join(file_path,config_path) + cfg, settings_show = Config(config_path) + + # overwrite split and detection method + if args.split: + cfg.split = args.split + if args.det_name: + cfg.det_name = args.det_name + cfg.split_data_path = os.path.join(file_dir_path, args.split_data_path) + cfg.input_path = os.path.join(file_dir_path, args.input_path) + cfg.output_path = os.path.join(file_dir_path, args.output_path) + + print('split_data_path: ',cfg.split_data_path) + + cat = args.cat + + # print configs + time_str = get_timestring() + log = os.path.join(cfg.output_path, 'log/log_%s_%s_%s.txt' % (time_str, cfg.dataset, cfg.split)) + mkdir_if_missing(log) + + log = open(log, 'w') + for idx, data in enumerate(settings_show): + print_log(data, log, display=False) + + # global ID counter used for all categories, not start from 1 for each category to prevent different + # categories of objects have the same ID. This allows visualization of all object categories together + # without ID conflicting, Also use 1 (not 0) as start because MOT benchmark requires positive ID + ID_start = 1 + + # run tracking + ID_start = main_per_cat(cfg, cat, log, ID_start) + + # combine results for every category + print_log('\ncombining results......', log=log) + combine_trk_cat(cfg.split, cfg.dataset, cfg.det_name, 'H%d' % cfg.num_hypo, cfg.num_hypo,cfg.split_data_path,cfg.output_path) + print_log('\nDone!', log=log) + log.close() + + +if __name__ == '__main__': + args = parse_args() + tracking(args) diff --git a/v2x/AB3DMOT_plugin/scripts/KITTI/evaluate.py b/v2x/AB3DMOT_plugin/scripts/KITTI/evaluate.py new file mode 100755 index 0000000..a6e70b1 --- /dev/null +++ b/v2x/AB3DMOT_plugin/scripts/KITTI/evaluate.py @@ -0,0 +1,1233 @@ +#!/usr/bin/env python +# encoding: utf-8 + +from __future__ import print_function +import matplotlib; matplotlib.use('Agg') +import sys, os, copy, math, numpy as np, matplotlib.pyplot as plt +from munkres import Munkres +from collections import defaultdict + +from . import mailpy +from AB3DMOT_plugin.AB3DMOT_libs.dist_metrics import iou + +num_sample_pts = 41.0 + +class tData: + """ + Utility class to load data. + """ + def __init__(self,frame=-1,obj_type="unset",truncation=-1,occlusion=-1,\ + obs_angle=-10,x1=-1,y1=-1,x2=-1,y2=-1,w=-1,h=-1,l=-1,\ + x=-1000,y=-1000,z=-1000,ry=-10,score=-1000,track_id=-1): + """ + Constructor, initializes the object given the parameters. + """ + + # init object data + self.frame = frame + self.track_id = track_id + self.obj_type = obj_type + self.truncation = truncation + self.occlusion = occlusion + self.obs_angle = obs_angle + self.x1 = x1 + self.y1 = y1 + self.x2 = x2 + self.y2 = y2 + self.w = w + self.h = h + self.l = l + self.x = x + self.y = y + self.z = z + self.ry = ry + self.score = score + self.ignored = False + self.valid = False + self.tracker = -1 + + def __str__(self): + """ + Print read data. + """ + + attrs = vars(self) + return '\n'.join("%s: %s" % item for item in attrs.items()) + +def boxoverlap(a, b, criterion="union"): + """ + boxoverlap computes intersection over union for bbox a and b in KITTI format. + If the criterion is 'union', overlap = (a inter b) / a union b). + If the criterion is 'a', overlap = (a inter b) / a, where b should be a dontcare area. + note that this is different from the iou in dist_metrics.py because this one uses 2D + box rather than projected 3D boxes to compute overlap + """ + + x1 = max(a.x1, b.x1) + y1 = max(a.y1, b.y1) + x2 = min(a.x2, b.x2) + y2 = min(a.y2, b.y2) + + w = x2-x1 + h = y2-y1 + + if w<=0. or h<=0.: + return 0. + inter = w*h + aarea = (a.x2-a.x1) * (a.y2-a.y1) + barea = (b.x2-b.x1) * (b.y2-b.y1) + + # intersection over union overlap + if criterion.lower()=="union": + o = inter / float(aarea+barea-inter) + elif criterion.lower()=="a": + o = float(inter) / float(aarea) + else: + raise TypeError("Unkown type for criterion") + return o + +class trackingEvaluation(object): + """ tracking statistics (CLEAR MOT, id-switches, fragments, ML/PT/MT, precision/recall) + MOTA - Multi-object tracking accuracy in [0,100] + MOTP - Multi-object tracking precision in [0,100] (3D) / [td,100] (2D) + MOTAL - Multi-object tracking accuracy in [0,100] with log10(id-switches) + + id-switches - number of id switches + fragments - number of fragmentations + + MT, PT, ML - number of mostly tracked, partially tracked and mostly lost trajectories + + recall - recall = percentage of detected targets + precision - precision = percentage of correctly detected targets + FAR - number of false alarms per frame + falsepositives - number of false positives (FP) + missed - number of missed targets (FN) + """ + + def __init__(self, t_sha, gt_path="AB3DMOT_plugin/scripts/KITTI", max_truncation = 0, min_height = 25, max_occlusion = 2, \ + mail=None, cls="car", eval_3diou=True, eval_2diou=False, num_hypo=1, thres=None): + # get number of sequences and + # get number of frames per sequence from test mapping + # (created while extracting the benchmark) + filename_test_mapping = os.path.join(gt_path, 'evaluate_tracking.seqmap.val') + self.n_frames = [] + self.sequence_name = [] + with open(filename_test_mapping, "r") as fh: + for i,l in enumerate(fh): + fields = l.split(" ") + self.sequence_name.append("%04d" % int(fields[0])) + self.n_frames.append(int(fields[3]) - int(fields[2])+1) + fh.close() + self.n_sequences = i+1 + + # mail object + self.mail = mail + + # class to evaluate, i.e. pedestrian or car + self.cls = cls + + # data and parameter + self.gt_path = os.path.join(gt_path, "label") + self.t_sha = t_sha + self.t_path = os.path.join("AB3DMOT_plugin/results/KITTI", t_sha, "data_%d" % (int(num_hypo)-1)) + + # statistics and numbers for evaluation + self.n_gt = 0 # number of ground truth detections minus ignored false negatives and true positives + self.n_igt = 0 # number of ignored ground truth detections + self.n_gts = [] # number of ground truth detections minus ignored false negatives and true positives PER SEQUENCE + self.n_igts = [] # number of ground ignored truth detections PER SEQUENCE + self.n_gt_trajectories = 0 + self.n_gt_seq = [] + self.n_tr = 0 # number of tracker detections minus ignored tracker detections + self.n_trs = [] # number of tracker detections minus ignored tracker detections PER SEQUENCE + self.n_itr = 0 # number of ignored tracker detections + self.n_itrs = [] # number of ignored tracker detections PER SEQUENCE + self.n_igttr = 0 # number of ignored ground truth detections where the corresponding associated tracker detection is also ignored + self.n_tr_trajectories = 0 + self.n_tr_seq = [] + self.MOTA = 0 + self.MOTP = 0 + self.MOTAL = 0 + self.MODA = 0 + self.MODP = 0 + self.MODP_t = [] + self.recall = 0 + self.precision = 0 + self.F1 = 0 + self.FAR = 0 + self.total_cost = 0 + self.itp = 0 # number of ignored true positives + self.itps = [] # number of ignored true positives PER SEQUENCE + self.tp = 0 # number of true positives including ignored true positives! + self.tps = [] # number of true positives including ignored true positives PER SEQUENCE + self.fn = 0 # number of false negatives WITHOUT ignored false negatives + self.fns = [] # number of false negatives WITHOUT ignored false negatives PER SEQUENCE + self.ifn = 0 # number of ignored false negatives + self.ifns = [] # number of ignored false negatives PER SEQUENCE + self.fp = 0 # number of false positives + # a bit tricky, the number of ignored false negatives and ignored true positives + # is subtracted, but if both tracker detection and ground truth detection + # are ignored this number is added again to avoid double counting + self.fps = [] # above PER SEQUENCE + self.mme = 0 + self.fragments = 0 + self.id_switches = 0 + self.MT = 0 + self.PT = 0 + self.ML = 0 + + self.eval_2diou = eval_2diou + self.eval_3diou = eval_3diou + if thres is None: + if eval_2diou: + self.min_overlap = 0.5 # minimum bounding box overlap for 3rd party metrics + elif eval_3diou: + self.min_overlap = 0.25 # minimum bounding box overlap for 3rd party metrics + else: assert False + else: + self.min_overlap = thres + # print('min overlap creteria is %f' % self.min_overlap) + + self.max_truncation = max_truncation # maximum truncation of an object for evaluation + self.max_occlusion = max_occlusion # maximum occlusion of an object for evaluation + self.min_height = min_height # minimum height of an object for evaluation + self.n_sample_points = 500 + + # this should be enough to hold all groundtruth trajectories + # is expanded if necessary and reduced in any case + self.gt_trajectories = [[] for x in range(self.n_sequences)] + self.ign_trajectories = [[] for x in range(self.n_sequences)] + + def loadGroundtruth(self): + """ + Helper function to load ground truth. + """ + + try: + self._loadData(self.gt_path, cls=self.cls, loading_groundtruth=True) + except IOError: + return False + return True + + def loadTracker(self): + """ + Helper function to load tracker data. + """ + + try: + if not self._loadData(self.t_path, cls=self.cls, loading_groundtruth=False): + return False + except IOError: + return False + return True + + def _loadData(self, root_dir, cls, min_score=-1000, loading_groundtruth=False): + """ + Generic loader for ground truth and tracking data. + Use loadGroundtruth() or loadTracker() to load this data. + Loads detections in KITTI format from textfiles. + """ + # construct objectDetections object to hold detection data + t_data = tData() + data = [] + eval_2d = True + eval_3d = True + + seq_data = [] + n_trajectories = 0 + n_trajectories_seq = [] + for seq, s_name in enumerate(self.sequence_name): + i = 0 + filename = os.path.join(root_dir, "%s.txt" % s_name) + f = open(filename, "r") + + f_data = [[] for x in range(self.n_frames[seq])] # current set has only 1059 entries, sufficient length is checked anyway + ids = [] + n_in_seq = 0 + id_frame_cache = [] + for line in f: + # KITTI tracking benchmark data format: + # (frame,tracklet_id,objectType,truncation,occlusion,alpha,x1,y1,x2,y2,h,w,l,X,Y,Z,ry) + line = line.strip() + fields = line.split(" ") + # classes that should be loaded (ignored neighboring classes) + if "car" in cls.lower(): + classes = ["car","van","bus","truck"] + elif "pedestrian" in cls.lower(): + classes = ["pedestrian","person_sitting"] + else: + classes = [cls.lower()] + classes += ["dontcare"] + if not any([s for s in classes if s in fields[2].lower()]): + continue + # get fields from table + t_data.frame = int(float(fields[0])) # frame + t_data.track_id = int(float(fields[1])) # id + t_data.obj_type = fields[2].lower() # object type [car, pedestrian, cyclist, ...] + t_data.truncation = int(float(fields[3])) # truncation [-1,0,1,2] + t_data.occlusion = int(float(fields[4])) # occlusion [-1,0,1,2] + t_data.obs_angle = float(fields[5]) # observation angle [rad] + t_data.x1 = float(fields[6]) # left [px] + t_data.y1 = float(fields[7]) # top [px] + t_data.x2 = float(fields[8]) # right [px] + t_data.y2 = float(fields[9]) # bottom [px] + t_data.h = float(fields[10]) # height [m] + t_data.w = float(fields[11]) # width [m] + t_data.l = float(fields[12]) # length [m] + t_data.x = float(fields[13]) # X [m] + t_data.y = float(fields[14]) # Y [m] + t_data.z = float(fields[15]) # Z [m] + t_data.ry = float(fields[16]) # yaw angle [rad] + t_data.corners_3d_cam = None + if not loading_groundtruth: + if len(fields) == 17: + t_data.score = -1 + elif len(fields) == 18: + t_data.score = float(fields[17]) # detection score + else: + self.mail.msg("file is not in KITTI format") + return + + # do not consider objects marked as invalid + if t_data.track_id == -1 and t_data.obj_type != "dontcare": + continue + + idx = t_data.frame + # check if length for frame data is sufficient + if idx >= len(f_data): + print("extend f_data", idx, len(f_data)) + f_data += [[] for x in range(max(500, idx-len(f_data)))] + try: + id_frame = (t_data.frame,t_data.track_id) + if id_frame in id_frame_cache and not loading_groundtruth: + self.mail.msg("track ids are not unique for sequence %d: frame %d" % (seq,t_data.frame)) + self.mail.msg("track id %d occured at least twice for this frame" % t_data.track_id) + self.mail.msg("Exiting...") + #continue # this allows to evaluate non-unique result files + return False + id_frame_cache.append(id_frame) + f_data[t_data.frame].append(copy.copy(t_data)) + except: + print(len(f_data), idx) + raise + + if t_data.track_id not in ids and t_data.obj_type!="dontcare": + ids.append(t_data.track_id) + n_trajectories +=1 + n_in_seq +=1 + + # check if uploaded data provides information for 2D and 3D evaluation + if not loading_groundtruth and eval_2d is True and(t_data.x1==-1 or t_data.x2==-1 or t_data.y1==-1 or t_data.y2==-1): + eval_2d = False + if not loading_groundtruth and eval_3d is True and(t_data.x==-1000 or t_data.y==-1000 or t_data.z==-1000): + eval_3d = False + + # only add existing frames + n_trajectories_seq.append(n_in_seq) + seq_data.append(f_data) + f.close() + + if not loading_groundtruth: + self.tracker=seq_data + self.n_tr_trajectories=n_trajectories + self.eval_2d = eval_2d + self.eval_3d = eval_3d + self.n_tr_seq = n_trajectories_seq + if self.n_tr_trajectories==0: + return False + else: + # split ground truth and DontCare areas + self.dcareas = [] + self.groundtruth = [] + for seq_idx in range(len(seq_data)): + seq_gt = seq_data[seq_idx] + s_g, s_dc = [],[] + for f in range(len(seq_gt)): + all_gt = seq_gt[f] + g,dc = [],[] + for gg in all_gt: + if gg.obj_type=="dontcare": + dc.append(gg) + else: + g.append(gg) + s_g.append(g) + s_dc.append(dc) + self.dcareas.append(s_dc) + self.groundtruth.append(s_g) + self.n_gt_seq=n_trajectories_seq + self.n_gt_trajectories=n_trajectories + return True + + def getThresholds(self, scores, num_gt, num_sample_pts=num_sample_pts): + # based on score of true positive to discretize the recall + # not necessarily have data on all points due to not fully recall the results, all the results point has zero precision + # compute the recall based on the gt positives + + # scores: the list of scores of the matched true positives + + scores = np.array(scores) + scores.sort() + scores = scores[::-1] + current_recall = 0 + thresholds = [] + recalls = [] + for i, score in enumerate(scores): + l_recall = (i + 1) / float(num_gt) + if i < (len(scores) - 1): + r_recall = (i + 2) / float(num_gt) + else: + r_recall = l_recall + if (((r_recall - current_recall) < (current_recall - l_recall)) and (i < (len(scores) - 1))): + continue + + thresholds.append(score) + recalls.append(current_recall) + current_recall += 1 / (num_sample_pts - 1.0) + + return thresholds[1:], recalls[1:] # throw the first one with 0 recall + + def reset(self): + self.n_gt = 0 # number of ground truth detections minus ignored false negatives and true positives + self.n_igt = 0 # number of ignored ground truth detections + self.n_tr = 0 # number of tracker detections minus ignored tracker detections + self.n_itr = 0 # number of ignored tracker detections + self.n_igttr = 0 # number of ignored ground truth detections where the corresponding associated tracker detection is also ignored + + self.MOTA = 0 + self.MOTP = 0 + self.MOTAL = 0 + self.MODA = 0 + self.MODP = 0 + self.MODP_t = [] + + self.recall = 0 + self.precision = 0 + self.F1 = 0 + self.FAR = 0 + + self.total_cost = 0 + self.itp = 0 + self.tp = 0 + self.fn = 0 + self.ifn = 0 + self.fp = 0 + + + self.n_gts = [] # number of ground truth detections minus ignored false negatives and true positives PER SEQUENCE + self.n_igts = [] # number of ground ignored truth detections PER SEQUENCE + self.n_trs = [] # number of tracker detections minus ignored tracker detections PER SEQUENCE + self.n_itrs = [] # number of ignored tracker detections PER SEQUENCE + + self.itps = [] # number of ignored true positives PER SEQUENCE + self.tps = [] # number of true positives including ignored true positives PER SEQUENCE + self.fns = [] # number of false negatives WITHOUT ignored false negatives PER SEQUENCE + self.ifns = [] # number of ignored false negatives PER SEQUENCE + self.fps = [] # above PER SEQUENCE + + + self.fragments = 0 + self.id_switches = 0 + self.MT = 0 + self.PT = 0 + self.ML = 0 + + self.gt_trajectories = [[] for x in range(self.n_sequences)] + self.ign_trajectories = [[] for x in range(self.n_sequences)] + + return + + def compute3rdPartyMetrics(self, threshold=-10000, recall_thres=1.0): + # def compute3rdPartyMetrics(self, threshold=3): + """ + Computes the metrics defined in + - Stiefelhagen 2008: Evaluating Multiple Object Tracking Performance: The CLEAR MOT Metrics + MOTA, MOTAL, MOTP + - Nevatia 2008: Global Data Association for Multi-Object Tracking Using Network Flows + MT/PT/ML + """ + + # construct Munkres object for Hungarian Method association + hm = Munkres() + max_cost = 1e9 + self.scores = list() + + # go through all frames and associate ground truth and tracker results + # groundtruth and tracker contain lists for every single frame containing lists of KITTI format detections + fr, ids = 0,0 + for seq_idx in range(len(self.groundtruth)): + seq_gt = self.groundtruth[seq_idx] + seq_dc = self.dcareas[seq_idx] # don't care areas + seq_tracker_before = self.tracker[seq_idx] + + # remove the tracks with low confidence for each frame + tracker_id_score = dict() + for frame in range(len(seq_tracker_before)): + tracks_tmp = seq_tracker_before[frame] + for index in range(len(tracks_tmp)): + trk_tmp = tracks_tmp[index] + id_tmp = trk_tmp.track_id + score_tmp = trk_tmp.score + + if id_tmp not in tracker_id_score.keys(): + tracker_id_score[id_tmp] = list() + tracker_id_score[id_tmp].append(score_tmp) + + id_average_score = dict() + to_delete_id = list() + for track_id, score_list in tracker_id_score.items(): + average_score = sum(score_list) / float(len(score_list)) + id_average_score[track_id] = average_score + if average_score < threshold: + to_delete_id.append(track_id) + + seq_tracker = list() + for frame in range(len(seq_tracker_before)): + seq_tracker_frame = list() + tracks_tmp = seq_tracker_before[frame] + for index in range(len(tracks_tmp)): + trk_tmp = tracks_tmp[index] + id_tmp = trk_tmp.track_id + average_score = id_average_score[id_tmp] + trk_tmp.score = average_score + if id_tmp not in to_delete_id: + seq_tracker_frame.append(trk_tmp) + seq_tracker.append(seq_tracker_frame) + + seq_trajectories = defaultdict(list) + seq_ignored = defaultdict(list) + + # statistics over the current sequence, check the corresponding + # variable comments in __init__ to get their meaning + seqtp = 0 + seqitp = 0 + seqfn = 0 + seqifn = 0 + seqfp = 0 + seqigt = 0 + seqitr = 0 + + last_ids = [[],[]] + + n_gts = 0 + n_trs = 0 + + for f in range(len(seq_gt)): # go through each frame + g = seq_gt[f] + dc = seq_dc[f] + + t = seq_tracker[f] + # counting total number of ground truth and tracker objects + self.n_gt += len(g) + self.n_tr += len(t) + + n_gts += len(g) + n_trs += len(t) + + # use hungarian method to associate, using box overlap 0..1 as cost + # build cost matrix + # row is gt, column is det + cost_matrix = [] + this_ids = [[],[]] + for gg in g: + # save current ids + this_ids[0].append(gg.track_id) + this_ids[1].append(-1) + gg.tracker = -1 + gg.id_switch = 0 + gg.fragmentation = 0 + cost_row = [] + for tt in t: + if self.eval_2diou: + c = 1 - boxoverlap(gg, tt) + elif self.eval_3diou: + c = 1 - iou(gg, tt, metric='iou_3d') + else: + assert False, 'error' + + # gating for box overlap + if c <= 1 - self.min_overlap: + cost_row.append(c) + else: + cost_row.append(max_cost) # = 1e9 + cost_matrix.append(cost_row) + # all ground truth trajectories are initially not associated + # extend groundtruth trajectories lists (merge lists) + seq_trajectories[gg.track_id].append(-1) + seq_ignored[gg.track_id].append(False) + + if len(g) == 0: + cost_matrix=[[]] + # associate + association_matrix = hm.compute(cost_matrix) + + # tmp variables for sanity checks and MODP computation + tmptp = 0 + tmpfp = 0 + tmpfn = 0 + tmpc = 0 # this will sum up the overlaps for all true positives + tmpcs = [0]*len(g) # this will save the overlaps for all true positives + # the reason is that some true positives might be ignored + # later such that the corrsponding overlaps can + # be subtracted from tmpc for MODP computation + + # mapping for tracker ids and ground truth ids + for row,col in association_matrix: + # apply gating on box overlap + c = cost_matrix[row][col] + if c < max_cost: + g[row].tracker = t[col].track_id + this_ids[1][row] = t[col].track_id + t[col].valid = True + g[row].distance = c + self.total_cost += 1-c + tmpc += 1-c + tmpcs[row] = 1-c + seq_trajectories[g[row].track_id][-1] = t[col].track_id + + # true positives are only valid associations + self.tp += 1 + tmptp += 1 + self.scores.append(t[col].score) + + else: + g[row].tracker = -1 + self.fn += 1 + tmpfn += 1 + + # associate tracker and DontCare areas + # ignore tracker in neighboring classes + nignoredtracker = 0 # number of ignored tracker detections + ignoredtrackers = dict() # will associate the track_id with -1 + # if it is not ignored and 1 if it is + # ignored; + # this is used to avoid double counting ignored + # cases, see the next loop + + for tt in t: + ignoredtrackers[tt.track_id] = -1 + # ignore detection if it belongs to a neighboring class or is + # smaller or equal to the minimum height + + tt_height = abs(tt.y1 - tt.y2) + if ((self.cls=="car" and tt.obj_type=="van") or (self.cls=="pedestrian" and tt.obj_type=="person_sitting") or tt_height<=self.min_height) and not tt.valid: + nignoredtracker+= 1 + tt.ignored = True + ignoredtrackers[tt.track_id] = 1 + continue + for d in dc: + # as KITTI does not provide ground truth 3D box for DontCare objects, we have to use + # 2D IoU here and a threshold of 0.5 for 2D IoU. + overlap = boxoverlap(tt, d, "a") + if overlap > 0.5 and not tt.valid: + tt.ignored = True + nignoredtracker += 1 + ignoredtrackers[tt.track_id] = 1 + break + + # check for ignored FN/TP (truncation or neighboring object class) + ignoredfn = 0 # the number of ignored false negatives + nignoredtp = 0 # the number of ignored true positives + nignoredpairs = 0 # the number of ignored pairs, i.e. a true positive + # which is ignored but where the associated tracker + # detection has already been ignored + + gi = 0 + for gg in g: + if gg.tracker < 0: + if gg.occlusion>self.max_occlusion or gg.truncation>self.max_truncation\ + or (self.cls=="car" and gg.obj_type=="van") or (self.cls=="pedestrian" and gg.obj_type=="person_sitting"): + seq_ignored[gg.track_id][-1] = True + gg.ignored = True + ignoredfn += 1 + + elif gg.tracker>=0: + if gg.occlusion>self.max_occlusion or gg.truncation>self.max_truncation\ + or (self.cls=="car" and gg.obj_type=="van") or (self.cls=="pedestrian" and gg.obj_type=="person_sitting"): + + seq_ignored[gg.track_id][-1] = True + gg.ignored = True + nignoredtp += 1 + + # if the associated tracker detection is already ignored, + # we want to avoid double counting ignored detections + if ignoredtrackers[gg.tracker] > 0: + nignoredpairs += 1 + + # for computing MODP, the overlaps from ignored detections + # are subtracted + tmpc -= tmpcs[gi] + gi += 1 + + # the below might be confusion, check the comments in __init__ + # to see what the individual statistics represent + + # nignoredtp is already associated, but should ignored + # ignoredfn is already missed, but should ignored + + # correct TP by number of ignored TP due to truncation + # ignored TP are shown as tracked in visualization + tmptp -= nignoredtp + + # count the number of ignored true positives + self.itp += nignoredtp + + # adjust the number of ground truth objects considered + # self.n_gt_adjusted = self.n_gt + self.n_gt -= (ignoredfn + nignoredtp) + + # count the number of ignored ground truth objects + self.n_igt += ignoredfn + nignoredtp + + # count the number of ignored tracker objects + self.n_itr += nignoredtracker + + # count the number of ignored pairs, i.e. associated tracker and + # ground truth objects that are both ignored + self.n_igttr += nignoredpairs + + # false negatives = associated gt bboxes exceding association threshold + non-associated gt bboxes + # + + # explanation of fn + # the original fn is in the matched gt where the score is not high enough + # len(g) - len(association amtrix), means that some gt is not matched in hungarian + # further - ignoredfn, means that some gt can be ignored + + tmpfn += len(g)-len(association_matrix)-ignoredfn + self.fn += len(g)-len(association_matrix)-ignoredfn + # self.fn += len(g)-len(association_matrix) + self.ifn += ignoredfn + + # false positives = tracker bboxes - associated tracker bboxes + # mismatches (mme_t) + tmpfp += len(t) - tmptp - nignoredtracker - nignoredtp + nignoredpairs + self.fp += len(t) - tmptp - nignoredtracker - nignoredtp + nignoredpairs + #tmpfp = len(t) - tmptp - nignoredtp # == len(t) - (tp - ignoredtp) - ignoredtp + #self.fp += len(t) - tmptp - nignoredtp + + # update sequence data + seqtp += tmptp + seqitp += nignoredtp + seqfp += tmpfp + seqfn += tmpfn + seqifn += ignoredfn + seqigt += ignoredfn + nignoredtp + seqitr += nignoredtracker + + # sanity checks + # - the number of true positives minues ignored true positives + # should be greater or equal to 0 + # - the number of false negatives should be greater or equal to 0 + # - the number of false positives needs to be greater or equal to 0 + # otherwise ignored detections might be counted double + # - the number of counted true positives (plus ignored ones) + # and the number of counted false negatives (plus ignored ones) + # should match the total number of ground truth objects + # - the number of counted true positives (plus ignored ones) + # and the number of counted false positives + # plus the number of ignored tracker detections should + # match the total number of tracker detections; note that + # nignoredpairs is subtracted here to avoid double counting + # of ignored detection sin nignoredtp and nignoredtracker + if tmptp<0: + print(tmptp, nignoredtp) + raise NameError("Something went wrong! TP is negative") + if tmpfn<0: + print(tmpfn, len(g), len(association_matrix), ignoredfn, nignoredpairs) + raise NameError("Something went wrong! FN is negative") + if tmpfp<0: + print(tmpfp, len(t), tmptp, nignoredtracker, nignoredtp, nignoredpairs) + raise NameError("Something went wrong! FP is negative") + if tmptp + tmpfn != len(g)-ignoredfn-nignoredtp: + print("seqidx", seq_idx) + print("frame ", f) + print("TP ", tmptp) + print("FN ", tmpfn) + print("FP ", tmpfp) + print("nGT ", len(g)) + print("nAss ", len(association_matrix)) + print("ign GT", ignoredfn) + print("ign TP", nignoredtp) + raise NameError("Something went wrong! nGroundtruth is not TP+FN") + if tmptp+tmpfp+nignoredtp+nignoredtracker-nignoredpairs != len(t): + print(seq_idx, f, len(t), tmptp, tmpfp) + print(len(association_matrix), association_matrix) + raise NameError("Something went wrong! nTracker is not TP+FP") + + # check for id switches or Fragmentations + # frag will be more than id switch, switch happens only when id is different but detection exists + # frag happens when id switch or detection is missing + for i,tt in enumerate(this_ids[0]): + # print(i) + # print(tt) + if tt in last_ids[0]: + idx = last_ids[0].index(tt) + tid = this_ids[1][i] # id in current tracker corresponding to the gt tt + lid = last_ids[1][idx] # id in last frame tracker corresponding to the gt tt + if tid != lid and lid != -1 and tid != -1: + if g[i].truncation=0 else 0 + lgt = 0 if ign_g[0] else 1 + for f in range(1,len(g)): + if ign_g[f]: + last_id = -1 + continue + lgt+=1 + if last_id != g[f] and last_id != -1 and g[f] != -1 and g[f-1] != -1: + tmpId_switches += 1 + self.id_switches += 1 + if f < len(g)-1 and g[f-1] != g[f] and last_id != -1 and g[f] != -1 and g[f+1] != -1: + tmpFragments += 1 + self.fragments += 1 + if g[f] != -1: + tracked += 1 + last_id = g[f] + # handle last frame; tracked state is handled in for loop (g[f]!=-1) + if len(g)>1 and g[f-1] != g[f] and last_id != -1 and g[f] != -1 and not ign_g[f]: + tmpFragments += 1 + self.fragments += 1 + + # compute MT/PT/ML + tracking_ratio = tracked / float(len(g) - sum(ign_g)) + if tracking_ratio > 0.8: + tmpMT += 1 + self.MT += 1 + elif tracking_ratio < 0.2: + tmpML += 1 + self.ML += 1 + else: # 0.2 <= tracking_ratio <= 0.8 + tmpPT += 1 + self.PT += 1 + + if (self.n_gt_trajectories-n_ignored_tr_total)==0: + self.MT = 0. + self.PT = 0. + self.ML = 0. + else: + self.MT /= float(self.n_gt_trajectories-n_ignored_tr_total) + self.PT /= float(self.n_gt_trajectories-n_ignored_tr_total) + self.ML /= float(self.n_gt_trajectories-n_ignored_tr_total) + + # precision/recall etc. + if (self.fp+self.tp)==0 or (self.tp+self.fn)==0: + self.recall = 0. + self.precision = 0. + else: + self.recall = self.tp/float(self.tp+self.fn) + self.precision = self.tp/float(self.fp+self.tp) + if (self.recall+self.precision)==0: + self.F1 = 0. + else: + self.F1 = 2.*(self.precision*self.recall)/(self.precision+self.recall) + if sum(self.n_frames)==0: + self.FAR = "n/a" + else: + self.FAR = self.fp/float(sum(self.n_frames)) + + # compute CLEARMOT + if self.n_gt==0: + self.MOTA = -float("inf") + self.MODA = -float("inf") + self.sMOTA = -float("inf") + else: + self.MOTA = 1 - (self.fn + self.fp + self.id_switches)/float(self.n_gt) + self.MODA = 1 - (self.fn + self.fp) / float(self.n_gt) + self.sMOTA = min(1, max(0, 1 - (self.fn + self.fp + self.id_switches - (1 - recall_thres) * self.n_gt) / float(recall_thres * self.n_gt))) + if self.tp==0: + self.MOTP = 0 + else: + self.MOTP = self.total_cost / float(self.tp) + if self.n_gt!=0: + if self.id_switches==0: + self.MOTAL = 1 - (self.fn + self.fp + self.id_switches)/float(self.n_gt) + else: + self.MOTAL = 1 - (self.fn + self.fp + math.log10(self.id_switches))/float(self.n_gt) + else: + self.MOTAL = -float("inf") + if sum(self.n_frames)==0: + self.MODP = "n/a" + else: + self.MODP = sum(self.MODP_t)/float(sum(self.n_frames)) + + self.num_gt = self.tp + self.fn + return True + + def createSummary_details(self): + """ + Generate and mail a summary of the results. + If mailpy.py is present, the summary is instead printed. + """ + + summary = "" + + summary += "evaluation: best results with single threshold".center(80,"=") + "\n" + summary += self.printEntry("Multiple Object Tracking Accuracy (MOTA)", self.MOTA) + "\n" + summary += self.printEntry("Multiple Object Tracking Precision (MOTP)", float(self.MOTP)) + "\n" + summary += self.printEntry("Multiple Object Tracking Accuracy (MOTAL)", self.MOTAL) + "\n" + summary += self.printEntry("Multiple Object Detection Accuracy (MODA)", self.MODA) + "\n" + summary += self.printEntry("Multiple Object Detection Precision (MODP)", float(self.MODP)) + "\n" + summary += "\n" + summary += self.printEntry("Recall", self.recall) + "\n" + summary += self.printEntry("Precision", self.precision) + "\n" + summary += self.printEntry("F1", self.F1) + "\n" + summary += self.printEntry("False Alarm Rate", self.FAR) + "\n" + summary += "\n" + summary += self.printEntry("Mostly Tracked", self.MT) + "\n" + summary += self.printEntry("Partly Tracked", self.PT) + "\n" + summary += self.printEntry("Mostly Lost", self.ML) + "\n" + summary += "\n" + summary += self.printEntry("True Positives", self.tp) + "\n" + #summary += self.printEntry("True Positives per Sequence", self.tps) + "\n" + summary += self.printEntry("Ignored True Positives", self.itp) + "\n" + #summary += self.printEntry("Ignored True Positives per Sequence", self.itps) + "\n" + summary += self.printEntry("False Positives", self.fp) + "\n" + #summary += self.printEntry("False Positives per Sequence", self.fps) + "\n" + summary += self.printEntry("False Negatives", self.fn) + "\n" + #summary += self.printEntry("False Negatives per Sequence", self.fns) + "\n" + summary += self.printEntry("Ignored False Negatives", self.ifn) + "\n" + #summary += self.printEntry("Ignored False Negatives per Sequence", self.ifns) + "\n" + # summary += self.printEntry("Missed Targets", self.fn) + "\n" + summary += self.printEntry("ID-switches", self.id_switches) + "\n" + summary += self.printEntry("Fragmentations", self.fragments) + "\n" + summary += "\n" + summary += self.printEntry("Ground Truth Objects (Total)", self.n_gt + self.n_igt) + "\n" + #summary += self.printEntry("Ground Truth Objects (Total) per Sequence", self.n_gts) + "\n" + summary += self.printEntry("Ignored Ground Truth Objects", self.n_igt) + "\n" + #summary += self.printEntry("Ignored Ground Truth Objects per Sequence", self.n_igts) + "\n" + summary += self.printEntry("Ground Truth Trajectories", self.n_gt_trajectories) + "\n" + summary += "\n" + summary += self.printEntry("Tracker Objects (Total)", self.n_tr) + "\n" + #summary += self.printEntry("Tracker Objects (Total) per Sequence", self.n_trs) + "\n" + summary += self.printEntry("Ignored Tracker Objects", self.n_itr) + "\n" + #summary += self.printEntry("Ignored Tracker Objects per Sequence", self.n_itrs) + "\n" + summary += self.printEntry("Tracker Trajectories", self.n_tr_trajectories) + "\n" + #summary += "\n" + #summary += self.printEntry("Ignored Tracker Objects with Associated Ignored Ground Truth Objects", self.n_igttr) + "\n" + summary += "="*80 + + return summary + + def createSummary_simple(self, threshold, recall): + """ + Generate and mail a summary of the results. + If mailpy.py is present, the summary is instead printed. + """ + + summary = "" + + summary += ("evaluation with confidence threshold %f, recall %f" % (threshold, recall)).center(80,"=") + "\n" + summary += ' sMOTA MOTA MOTP MT ML IDS FRAG F1 Prec Recall FAR TP FP FN\n' + + summary += '{:.4f} {:.4f} {:.4f} {:.4f} {:.4f} {:5d} {:5d} {:.4f} {:.4f} {:.4f} {:.4f} {:5d} {:5d} {:5d}\n'.format( \ + self.sMOTA, self.MOTA, self.MOTP, self.MT, self.ML, self.id_switches, self.fragments, \ + self.F1, self.precision, self.recall, self.FAR, self.tp, self.fp, self.fn) + summary += "="*80 + + return summary + + def printEntry(self, key, val,width=(70,10)): + """ + Pretty print an entry in a table fashion. + """ + + s_out = key.ljust(width[0]) + if type(val)==int: + s = "%%%dd" % width[1] + s_out += s % val + elif type(val)==float: + s = "%%%d.4f" % (width[1]) + s_out += s % val + else: + s_out += ("%s"%val).rjust(width[1]) + return s_out + + def saveToStats(self, dump, threshold=None, recall=None): + """ + Save the statistics in a whitespace separate file. + """ + + if threshold is None: summary = self.createSummary_details() + else: summary = self.createSummary_simple(threshold, recall) + self.mail.msg(summary) # mail or print the summary. + print(summary, file=dump) + +class stat: + """ + Utility class to load data. + """ + def __init__(self, t_sha, cls, suffix, dump): + """ + Constructor, initializes the object given the parameters. + """ + + # init object data + self.mota = 0 + self.motp = 0 + self.F1 = 0 + self.precision = 0 + self.fp = 0 + self.fn = 0 + self.sMOTA = 0 + + self.mota_list = list() + self.motp_list = list() + self.sMOTA_list = list() + self.f1_list = list() + self.precision_list = list() + self.fp_list = list() + self.fn_list = list() + self.recall_list = list() + + self.t_sha = t_sha + self.cls = cls + self.suffix = suffix + self.dump = dump + + def update(self, data): + self.mota += data['mota'] + self.motp += data['motp'] + self.F1 += data['F1'] + # self.moda += data['moda'] + # self.modp += data['modp'] + self.precision += data['precision'] + self.fp += data['fp'] + self.fn += data['fn'] + self.sMOTA += data['sMOTA'] + + self.mota_list.append(data['mota']) + self.sMOTA_list.append(data['sMOTA']) + self.motp_list.append(data['motp']) + self.f1_list.append(data['F1']) + self.precision_list.append(data['precision']) + self.fp_list.append(data['fp']) + self.fn_list.append(data['fn']) + self.recall_list.append(data['recall']) + + def output(self): + self.sAMOTA = self.sMOTA / (num_sample_pts - 1) + self.amota = self.mota / (num_sample_pts - 1) + self.amotp = self.motp / (num_sample_pts - 1) + + def print_summary(self): + summary = "" + + summary += ("evaluation: average over recall").center(80,"=") + "\n" + summary += ' sAMOTA AMOTA AMOTP \n' + + summary += '{:.4f} {:.4f} {:.4f}\n'.format(self.sAMOTA, self.amota, self.amotp) + summary += "="*80 + + print(summary, file=self.dump) + + return summary + + def plot_over_recall(self, data_list, title, y_name, save_path): + # add extra zero at the end + largest_recall = self.recall_list[-1] + extra_zero = np.arange(largest_recall, 1, 0.01).tolist() + len_extra = len(extra_zero) + y_zero = [0] * len_extra + + fig = plt.figure() + ax = fig.add_subplot(111) + ax.plot(np.array(self.recall_list + extra_zero), np.array(data_list + y_zero)) + # ax.set_title(title, fontsize=20) + ax.set_ylabel(y_name, fontsize=20) + ax.set_xlabel('Recall', fontsize=20) + ax.set_xlim(0.0, 1.0) + plt.xticks(fontsize=20) + plt.yticks(fontsize=20) + plt.tight_layout() + if y_name in ['sMOTA', 'MOTA', 'MOTP', 'F1', 'Precision']: + ax.set_ylim(0.0, 1.0) + else: + ax.set_ylim(0.0, max(data_list)) + + if y_name in ['MOTA', 'F1']: + max_ind = np.argmax(np.array(data_list)) + # print(max_ind) + plt.axvline(self.recall_list[max_ind], ymax=data_list[max_ind], color='r') + plt.plot(self.recall_list[max_ind], data_list[max_ind], 'or', markersize=12) + plt.text(self.recall_list[max_ind]-0.05, data_list[max_ind]+0.03, '%.2f' % (data_list[max_ind] * 100), fontsize=20) + fig.savefig(save_path) + plt.close() + # zxc + + def plot(self): + save_dir = os.path.join("AB3DMOT_plugin/results/KITTI", self.t_sha) + + self.plot_over_recall(self.mota_list, 'MOTA - Recall Curve', 'MOTA', os.path.join(save_dir, 'MOTA_recall_curve_%s_%s.pdf' % (self.cls, self.suffix))) + self.plot_over_recall(self.sMOTA_list, 'sMOTA - Recall Curve', 'sMOTA', os.path.join(save_dir, 'sMOTA_recall_curve_%s_%s.pdf' % (self.cls, self.suffix))) + self.plot_over_recall(self.motp_list, 'MOTP - Recall Curve', 'MOTP', os.path.join(save_dir, 'MOTP_recall_curve_%s_%s.pdf' % (self.cls, self.suffix))) + self.plot_over_recall(self.f1_list, 'F1 - Recall Curve', 'F1', os.path.join(save_dir, 'F1_recall_curve_%s_%s.pdf' % (self.cls, self.suffix))) + self.plot_over_recall(self.fp_list, 'False Positive - Recall Curve', 'False Positive', os.path.join(save_dir, 'FP_recall_curve_%s_%s.pdf' % (self.cls, self.suffix))) + self.plot_over_recall(self.fn_list, 'False Negative - Recall Curve', 'False Negative', os.path.join(save_dir, 'FN_recall_curve_%s_%s.pdf' % (self.cls, self.suffix))) + self.plot_over_recall(self.precision_list, 'Precision - Recall Curve', 'Precision', os.path.join(save_dir, 'precision_recall_curve_%s_%s.pdf' % (self.cls, self.suffix))) + +def evaluate(result_sha,mail,num_hypo,eval_3diou,eval_2diou,thres): + """ + Entry point for evaluation, will load the data and start evaluation for + CAR and PEDESTRIAN if available. + """ + + # start evaluation and instanciated eval object + if eval_3diou: + mail.msg("Processing Result for KITTI 3D MOT Benchmark") + elif eval_2diou: + mail.msg("Processing Result for KITTI 2D MOT Benchmark") + else: + assert False, 'error' + classes = [] + # for c in ("car", "pedestrian", "cyclist"): + for c in ["car"]: + e = trackingEvaluation(t_sha=result_sha, mail=mail,cls=c,eval_3diou=eval_3diou,eval_2diou=eval_2diou,num_hypo=num_hypo,thres=thres) + # load tracker data and check provided classes + try: + if not e.loadTracker(): + continue + mail.msg("Loading Results - Success") + mail.msg("Evaluate Object Class: %s" % c.upper()) + classes.append(c) + except: + mail.msg("Feel free to contact us (lenz@kit.edu), if you receive this error message:") + mail.msg(" Caught exception while loading result data.") + break + # load groundtruth data for this class + if not e.loadGroundtruth(): + raise ValueError("Ground truth not found.") + mail.msg("Loading Groundtruth - Success") + # sanity checks + if len(e.groundtruth) != len(e.tracker): + mail.msg("The uploaded data does not provide results for every sequence: %d vs %d" % (len(e.groundtruth), len(e.tracker))) + return False + mail.msg("Loaded %d Sequences." % len(e.groundtruth)) + mail.msg("Start Evaluation...") + + if eval_3diou: suffix = 'eval3D' + else: suffix = 'eval2D' + filename = os.path.join(e.t_path, "../summary_%s_average_%s.txt" % (c, suffix)); dump = open(filename, "w+") + stat_meter = stat(t_sha=result_sha, cls=c, suffix=suffix, dump=dump) + e.compute3rdPartyMetrics() + + # evaluate the mean average metrics + best_mota, best_threshold = 0, -10000 + threshold_list, recall_list = e.getThresholds(e.scores, e.num_gt) + for threshold_tmp, recall_tmp in zip(threshold_list, recall_list): + data_tmp = dict() + e.reset() + e.compute3rdPartyMetrics(threshold_tmp, recall_tmp) + data_tmp['mota'], data_tmp['motp'], data_tmp['moda'], data_tmp['modp'], data_tmp['precision'], \ + data_tmp['F1'], data_tmp['fp'], data_tmp['fn'], data_tmp['recall'], data_tmp['sMOTA'] = \ + e.MOTA, e.MOTP, e.MODA, e.MODP, e.precision, e.F1, e.fp, e.fn, e.recall, e.sMOTA + stat_meter.update(data_tmp) + mota_tmp = e.MOTA + if mota_tmp > best_mota: + best_threshold = threshold_tmp + best_mota = mota_tmp + e.saveToStats(dump, threshold_tmp, recall_tmp) + + e.reset() + e.compute3rdPartyMetrics(best_threshold) + e.saveToStats(dump) + + stat_meter.output() + summary = stat_meter.print_summary() + stat_meter.plot() + mail.msg(summary) # mail or print the summary. + dump.close() + + # finish + if len(classes)==0: + mail.msg("The uploaded results could not be evaluated. Check for format errors.") + return False + mail.msg("Thank you for participating in our benchmark!") + return True + +######################################################################### +# entry point of evaluation script +# input: +# - result_sha (unique key of results) +# - 2D or 3D (using 2D or 3D MOT evaluation system) +if __name__ == "__main__": + + # check for correct number of arguments. if user_sha and email are not supplied, + # no notification email is sent (this option is used for auto-updates) + if len(sys.argv)!=3 and len(sys.argv)!=4 and len(sys.argv)!=5: + print("Usage: python3 scripts/KITTI/evaluate.py result_sha num_hypothesis(e.g., 1) dimension(e.g., 2D or 3D) thres(e.g., 0.25)") + sys.exit(1); + + # get unique sha key of submitted results + result_sha = sys.argv[1] + num_hypo = sys.argv[2] + mail = mailpy.Mail("") + # + if len(sys.argv)>=4: + if sys.argv[3] == '2D': + eval_3diou, eval_2diou = False, True # eval 2d + elif sys.argv[3] == '3D': + eval_3diou, eval_2diou = True, False # eval 3d + else: + print("Usage: python3 scripts/KITTI/evaluate.py result_sha num_hypothesis(e.g., 1) dimension(e.g., 2D or 3D) thres(e.g., 0.25)") + sys.exit(1); + if len(sys.argv)==5: thres = float(sys.argv[4]) + else: thres = None + else: + eval_3diou, eval_2diou = True, False # eval 3d + thres = None + + + + # evaluate results + success = evaluate(result_sha,mail,num_hypo,eval_3diou,eval_2diou,thres) \ No newline at end of file diff --git a/v2x/AB3DMOT_plugin/scripts/KITTI/mailpy.py b/v2x/AB3DMOT_plugin/scripts/KITTI/mailpy.py new file mode 100755 index 0000000..4f3a097 --- /dev/null +++ b/v2x/AB3DMOT_plugin/scripts/KITTI/mailpy.py @@ -0,0 +1,12 @@ +class Mail: + """ Dummy class to print messages without sending e-mails""" + def __init__(self,mailaddress): + pass + def msg(self,msg): + print(msg) + def finalize(self,success,benchmark,sha_key,mailaddress=None): + if success: + print("Results for %s (benchmark: %s) sucessfully created" % (benchmark,sha_key)) + else: + print("Creating results for %s (benchmark: %s) failed" % (benchmark,sha_key)) + diff --git a/v2x/AB3DMOT_plugin/scripts/KITTI/munkres.py b/v2x/AB3DMOT_plugin/scripts/KITTI/munkres.py new file mode 100755 index 0000000..9837281 --- /dev/null +++ b/v2x/AB3DMOT_plugin/scripts/KITTI/munkres.py @@ -0,0 +1,794 @@ +#!/usr/bin/env python +# -*- coding: iso-8859-1 -*- + +# Documentation is intended to be processed by Epydoc. + +""" +Introduction +============ + +The Munkres module provides an implementation of the Munkres algorithm +(also called the Hungarian algorithm or the Kuhn-Munkres algorithm), +useful for solving the Assignment Problem. + +Assignment Problem +================== + +Let *C* be an *n*\ x\ *n* matrix representing the costs of each of *n* workers +to perform any of *n* jobs. The assignment problem is to assign jobs to +workers in a way that minimizes the total cost. Since each worker can perform +only one job and each job can be assigned to only one worker the assignments +represent an independent set of the matrix *C*. + +One way to generate the optimal set is to create all permutations of +the indexes necessary to traverse the matrix so that no row and column +are used more than once. For instance, given this matrix (expressed in +Python):: + + matrix = [[5, 9, 1], + [10, 3, 2], + [8, 7, 4]] + +You could use this code to generate the traversal indexes:: + + def permute(a, results): + if len(a) == 1: + results.insert(len(results), a) + + else: + for i in range(0, len(a)): + element = a[i] + a_copy = [a[j] for j in range(0, len(a)) if j != i] + subresults = [] + permute(a_copy, subresults) + for subresult in subresults: + result = [element] + subresult + results.insert(len(results), result) + + results = [] + permute(range(len(matrix)), results) # [0, 1, 2] for a 3x3 matrix + +After the call to permute(), the results matrix would look like this:: + + [[0, 1, 2], + [0, 2, 1], + [1, 0, 2], + [1, 2, 0], + [2, 0, 1], + [2, 1, 0]] + +You could then use that index matrix to loop over the original cost matrix +and calculate the smallest cost of the combinations:: + + n = len(matrix) + minval = sys.maxint + for row in range(n): + cost = 0 + for col in range(n): + cost += matrix[row][col] + minval = min(cost, minval) + + print minval + +While this approach works fine for small matrices, it does not scale. It +executes in O(*n*!) time: Calculating the permutations for an *n*\ x\ *n* +matrix requires *n*! operations. For a 12x12 matrix, that's 479,001,600 +traversals. Even if you could manage to perform each traversal in just one +millisecond, it would still take more than 133 hours to perform the entire +traversal. A 20x20 matrix would take 2,432,902,008,176,640,000 operations. At +an optimistic millisecond per operation, that's more than 77 million years. + +The Munkres algorithm runs in O(*n*\ ^3) time, rather than O(*n*!). This +package provides an implementation of that algorithm. + +This version is based on +http://www.public.iastate.edu/~ddoty/HungarianAlgorithm.html. + +This version was written for Python by Brian Clapper from the (Ada) algorithm +at the above web site. (The ``Algorithm::Munkres`` Perl version, in CPAN, was +clearly adapted from the same web site.) + +Usage +===== + +Construct a Munkres object:: + + from munkres import Munkres + + m = Munkres() + +Then use it to compute the lowest cost assignment from a cost matrix. Here's +a sample program:: + + from munkres import Munkres, print_matrix + + matrix = [[5, 9, 1], + [10, 3, 2], + [8, 7, 4]] + m = Munkres() + indexes = m.compute(matrix) + print_matrix(matrix, msg='Lowest cost through this matrix:') + total = 0 + for row, column in indexes: + value = matrix[row][column] + total += value + print '(%d, %d) -> %d' % (row, column, value) + print 'total cost: %d' % total + +Running that program produces:: + + Lowest cost through this matrix: + [5, 9, 1] + [10, 3, 2] + [8, 7, 4] + (0, 0) -> 5 + (1, 1) -> 3 + (2, 2) -> 4 + total cost=12 + +The instantiated Munkres object can be used multiple times on different +matrices. + +Non-square Cost Matrices +======================== + +The Munkres algorithm assumes that the cost matrix is square. However, it's +possible to use a rectangular matrix if you first pad it with 0 values to make +it square. This module automatically pads rectangular cost matrices to make +them square. + +Notes: + +- The module operates on a *copy* of the caller's matrix, so any padding will + not be seen by the caller. +- The cost matrix must be rectangular or square. An irregular matrix will + *not* work. + +Calculating Profit, Rather than Cost +==================================== + +The cost matrix is just that: A cost matrix. The Munkres algorithm finds +the combination of elements (one from each row and column) that results in +the smallest cost. It's also possible to use the algorithm to maximize +profit. To do that, however, you have to convert your profit matrix to a +cost matrix. The simplest way to do that is to subtract all elements from a +large value. For example:: + + from munkres import Munkres, print_matrix + + matrix = [[5, 9, 1], + [10, 3, 2], + [8, 7, 4]] + cost_matrix = [] + for row in matrix: + cost_row = [] + for col in row: + cost_row += [sys.maxint - col] + cost_matrix += [cost_row] + + m = Munkres() + indexes = m.compute(cost_matrix) + print_matrix(matrix, msg='Highest profit through this matrix:') + total = 0 + for row, column in indexes: + value = matrix[row][column] + total += value + print '(%d, %d) -> %d' % (row, column, value) + + print 'total profit=%d' % total + +Running that program produces:: + + Highest profit through this matrix: + [5, 9, 1] + [10, 3, 2] + [8, 7, 4] + (0, 1) -> 9 + (1, 0) -> 10 + (2, 2) -> 4 + total profit=23 + +The ``munkres`` module provides a convenience method for creating a cost +matrix from a profit matrix. Since it doesn't know whether the matrix contains +floating point numbers, decimals, or integers, you have to provide the +conversion function; but the convenience method takes care of the actual +creation of the cost matrix:: + + import munkres + + cost_matrix = munkres.make_cost_matrix(matrix, + lambda cost: sys.maxint - cost) + +So, the above profit-calculation program can be recast as:: + + from munkres import Munkres, print_matrix, make_cost_matrix + + matrix = [[5, 9, 1], + [10, 3, 2], + [8, 7, 4]] + cost_matrix = make_cost_matrix(matrix, lambda cost: sys.maxint - cost) + m = Munkres() + indexes = m.compute(cost_matrix) + print_matrix(matrix, msg='Lowest cost through this matrix:') + total = 0 + for row, column in indexes: + value = matrix[row][column] + total += value + print '(%d, %d) -> %d' % (row, column, value) + print 'total profit=%d' % total + +References +========== + +1. http://www.public.iastate.edu/~ddoty/HungarianAlgorithm.html + +2. Harold W. Kuhn. The Hungarian Method for the assignment problem. + *Naval Research Logistics Quarterly*, 2:83-97, 1955. + +3. Harold W. Kuhn. Variants of the Hungarian method for assignment + problems. *Naval Research Logistics Quarterly*, 3: 253-258, 1956. + +4. Munkres, J. Algorithms for the Assignment and Transportation Problems. + *Journal of the Society of Industrial and Applied Mathematics*, + 5(1):32-38, March, 1957. + +5. http://en.wikipedia.org/wiki/Hungarian_algorithm + +Copyright and License +===================== + +This software is released under a BSD license, adapted from + + +Copyright (c) 2008 Brian M. Clapper +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +* Neither the name "clapper.org" nor the names of its contributors may be + used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. +""" + +__docformat__ = 'restructuredtext' + +# --------------------------------------------------------------------------- +# Imports +# --------------------------------------------------------------------------- + +import copy, sys + +# --------------------------------------------------------------------------- +# Exports +# --------------------------------------------------------------------------- + +__all__ = ['Munkres', 'make_cost_matrix'] + +# --------------------------------------------------------------------------- +# Globals +# --------------------------------------------------------------------------- + +# Info about the module +__version__ = "1.0.5.4" +__author__ = "Brian Clapper, bmc@clapper.org" +__url__ = "http://bmc.github.com/munkres/" +__copyright__ = "(c) 2008 Brian M. Clapper" +__license__ = "BSD-style license" + +# --------------------------------------------------------------------------- +# Classes +# --------------------------------------------------------------------------- + +class Munkres: + """ + Calculate the Munkres solution to the classical assignment problem. + See the module documentation for usage. + """ + + def __init__(self): + """Create a new instance""" + self.C = None + self.row_covered = [] + self.col_covered = [] + self.n = 0 + self.Z0_r = 0 + self.Z0_c = 0 + self.marked = None + self.path = None + + def make_cost_matrix(profit_matrix, inversion_function): + """ + **DEPRECATED** + + Please use the module function ``make_cost_matrix()``. + """ + import munkres + return munkres.make_cost_matrix(profit_matrix, inversion_function) + + make_cost_matrix = staticmethod(make_cost_matrix) + + def pad_matrix(self, matrix, pad_value=0): + """ + Pad a possibly non-square matrix to make it square. + + :Parameters: + matrix : list of lists + matrix to pad + + pad_value : int + value to use to pad the matrix + + :rtype: list of lists + :return: a new, possibly padded, matrix + """ + max_columns = 0 + total_rows = len(matrix) + + for row in matrix: + max_columns = max(max_columns, len(row)) + + total_rows = max(max_columns, total_rows) + + new_matrix = [] + for row in matrix: + row_len = len(row) + new_row = row[:] + if total_rows > row_len: + # Row too short. Pad it. + new_row += [0] * (total_rows - row_len) + new_matrix += [new_row] + + while len(new_matrix) < total_rows: + new_matrix += [[0] * total_rows] + + return new_matrix + + def compute(self, cost_matrix): + """ + Compute the indexes for the lowest-cost pairings between rows and + columns in the database. Returns a list of (row, column) tuples + that can be used to traverse the matrix. + + :Parameters: + cost_matrix : list of lists + The cost matrix. If this cost matrix is not square, it + will be padded with zeros, via a call to ``pad_matrix()``. + (This method does *not* modify the caller's matrix. It + operates on a copy of the matrix.) + + **WARNING**: This code handles square and rectangular + matrices. It does *not* handle irregular matrices. + + :rtype: list + :return: A list of ``(row, column)`` tuples that describe the lowest + cost path through the matrix + + """ + self.C = self.pad_matrix(cost_matrix) + self.n = len(self.C) + self.original_length = len(cost_matrix) + self.original_width = len(cost_matrix[0]) + self.row_covered = [False for i in range(self.n)] + self.col_covered = [False for i in range(self.n)] + self.Z0_r = 0 + self.Z0_c = 0 + self.path = self.__make_matrix(self.n * 2, 0) + self.marked = self.__make_matrix(self.n, 0) + + done = False + step = 1 + + steps = { 1 : self.__step1, + 2 : self.__step2, + 3 : self.__step3, + 4 : self.__step4, + 5 : self.__step5, + 6 : self.__step6 } + + while not done: + try: + func = steps[step] + step = func() + except KeyError: + done = True + + # Look for the starred columns + results = [] + for i in range(self.original_length): + for j in range(self.original_width): + if self.marked[i][j] == 1: + results += [(i, j)] + + return results + + def __copy_matrix(self, matrix): + """Return an exact copy of the supplied matrix""" + return copy.deepcopy(matrix) + + def __make_matrix(self, n, val): + """Create an *n*x*n* matrix, populating it with the specific value.""" + matrix = [] + for i in range(n): + matrix += [[val for j in range(n)]] + return matrix + + def __step1(self): + """ + For each row of the matrix, find the smallest element and + subtract it from every element in its row. Go to Step 2. + """ + C = self.C + n = self.n + for i in range(n): + minval = min(self.C[i]) + # Find the minimum value for this row and subtract that minimum + # from every element in the row. + for j in range(n): + self.C[i][j] -= minval + + return 2 + + def __step2(self): + """ + Find a zero (Z) in the resulting matrix. If there is no starred + zero in its row or column, star Z. Repeat for each element in the + matrix. Go to Step 3. + """ + n = self.n + for i in range(n): + for j in range(n): + if (self.C[i][j] == 0) and \ + (not self.col_covered[j]) and \ + (not self.row_covered[i]): + self.marked[i][j] = 1 + self.col_covered[j] = True + self.row_covered[i] = True + + self.__clear_covers() + return 3 + + def __step3(self): + """ + Cover each column containing a starred zero. If K columns are + covered, the starred zeros describe a complete set of unique + assignments. In this case, Go to DONE, otherwise, Go to Step 4. + """ + n = self.n + count = 0 + for i in range(n): + for j in range(n): + if self.marked[i][j] == 1: + self.col_covered[j] = True + count += 1 + + if count >= n: + step = 7 # done + else: + step = 4 + + return step + + def __step4(self): + """ + Find a noncovered zero and prime it. If there is no starred zero + in the row containing this primed zero, Go to Step 5. Otherwise, + cover this row and uncover the column containing the starred + zero. Continue in this manner until there are no uncovered zeros + left. Save the smallest uncovered value and Go to Step 6. + """ + step = 0 + done = False + row = -1 + col = -1 + star_col = -1 + while not done: + (row, col) = self.__find_a_zero() + if row < 0: + done = True + step = 6 + else: + self.marked[row][col] = 2 + star_col = self.__find_star_in_row(row) + if star_col >= 0: + col = star_col + self.row_covered[row] = True + self.col_covered[col] = False + else: + done = True + self.Z0_r = row + self.Z0_c = col + step = 5 + + return step + + def __step5(self): + """ + Construct a series of alternating primed and starred zeros as + follows. Let Z0 represent the uncovered primed zero found in Step 4. + Let Z1 denote the starred zero in the column of Z0 (if any). + Let Z2 denote the primed zero in the row of Z1 (there will always + be one). Continue until the series terminates at a primed zero + that has no starred zero in its column. Unstar each starred zero + of the series, star each primed zero of the series, erase all + primes and uncover every line in the matrix. Return to Step 3 + """ + count = 0 + path = self.path + path[count][0] = self.Z0_r + path[count][1] = self.Z0_c + done = False + while not done: + row = self.__find_star_in_col(path[count][1]) + if row >= 0: + count += 1 + path[count][0] = row + path[count][1] = path[count-1][1] + else: + done = True + + if not done: + col = self.__find_prime_in_row(path[count][0]) + count += 1 + path[count][0] = path[count-1][0] + path[count][1] = col + + self.__convert_path(path, count) + self.__clear_covers() + self.__erase_primes() + return 3 + + def __step6(self): + """ + Add the value found in Step 4 to every element of each covered + row, and subtract it from every element of each uncovered column. + Return to Step 4 without altering any stars, primes, or covered + lines. + """ + minval = self.__find_smallest() + for i in range(self.n): + for j in range(self.n): + if self.row_covered[i]: + self.C[i][j] += minval + if not self.col_covered[j]: + self.C[i][j] -= minval + return 4 + + def __find_smallest(self): + """Find the smallest uncovered value in the matrix.""" + try: + minval = sys.maxint + except AttributeError: + minval = sys.maxsize + for i in range(self.n): + for j in range(self.n): + if (not self.row_covered[i]) and (not self.col_covered[j]): + if minval > self.C[i][j]: + minval = self.C[i][j] + return minval + + def __find_a_zero(self): + """Find the first uncovered element with value 0""" + row = -1 + col = -1 + i = 0 + n = self.n + done = False + + while not done: + j = 0 + while True: + if (self.C[i][j] == 0) and \ + (not self.row_covered[i]) and \ + (not self.col_covered[j]): + row = i + col = j + done = True + j += 1 + if j >= n: + break + i += 1 + if i >= n: + done = True + + return (row, col) + + def __find_star_in_row(self, row): + """ + Find the first starred element in the specified row. Returns + the column index, or -1 if no starred element was found. + """ + col = -1 + for j in range(self.n): + if self.marked[row][j] == 1: + col = j + break + + return col + + def __find_star_in_col(self, col): + """ + Find the first starred element in the specified row. Returns + the row index, or -1 if no starred element was found. + """ + row = -1 + for i in range(self.n): + if self.marked[i][col] == 1: + row = i + break + + return row + + def __find_prime_in_row(self, row): + """ + Find the first prime element in the specified row. Returns + the column index, or -1 if no starred element was found. + """ + col = -1 + for j in range(self.n): + if self.marked[row][j] == 2: + col = j + break + + return col + + def __convert_path(self, path, count): + for i in range(count+1): + if self.marked[path[i][0]][path[i][1]] == 1: + self.marked[path[i][0]][path[i][1]] = 0 + else: + self.marked[path[i][0]][path[i][1]] = 1 + + def __clear_covers(self): + """Clear all covered matrix cells""" + for i in range(self.n): + self.row_covered[i] = False + self.col_covered[i] = False + + def __erase_primes(self): + """Erase all prime markings""" + for i in range(self.n): + for j in range(self.n): + if self.marked[i][j] == 2: + self.marked[i][j] = 0 + +# --------------------------------------------------------------------------- +# Functions +# --------------------------------------------------------------------------- + +def make_cost_matrix(profit_matrix, inversion_function): + """ + Create a cost matrix from a profit matrix by calling + 'inversion_function' to invert each value. The inversion + function must take one numeric argument (of any type) and return + another numeric argument which is presumed to be the cost inverse + of the original profit. + + This is a static method. Call it like this: + + .. python:: + + cost_matrix = Munkres.make_cost_matrix(matrix, inversion_func) + + For example: + + .. python:: + + cost_matrix = Munkres.make_cost_matrix(matrix, lambda x : sys.maxint - x) + + :Parameters: + profit_matrix : list of lists + The matrix to convert from a profit to a cost matrix + + inversion_function : function + The function to use to invert each entry in the profit matrix + + :rtype: list of lists + :return: The converted matrix + """ + cost_matrix = [] + for row in profit_matrix: + cost_matrix.append([inversion_function(value) for value in row]) + return cost_matrix + +def print_matrix(matrix, msg=None): + """ + Convenience function: Displays the contents of a matrix of integers. + + :Parameters: + matrix : list of lists + Matrix to print + + msg : str + Optional message to print before displaying the matrix + """ + import math + + if msg is not None: + print(msg) + + # Calculate the appropriate format width. + width = 0 + for row in matrix: + for val in row: + width = max(width, int(math.log10(val)) + 1) + + # Make the format string + format = '%%%dd' % width + + # Print the matrix + for row in matrix: + sep = '[' + for val in row: + sys.stdout.write(sep + format % val) + sep = ', ' + sys.stdout.write(']\n') + +# --------------------------------------------------------------------------- +# Main +# --------------------------------------------------------------------------- + +if __name__ == '__main__': + + + matrices = [ + # Square + ([[400, 150, 400], + [400, 450, 600], + [300, 225, 300]], + 850 # expected cost + ), + + # Rectangular variant + ([[400, 150, 400, 1], + [400, 450, 600, 2], + [300, 225, 300, 3]], + 452 # expected cost + ), + + # Square + ([[10, 10, 8], + [ 9, 8, 1], + [ 9, 7, 4]], + 18 + ), + + # Rectangular variant + ([[10, 10, 8, 11], + [ 9, 8, 1, 1], + [ 9, 7, 4, 10]], + 15 + ), + ] + + m = Munkres() + for cost_matrix, expected_total in matrices: + print_matrix(cost_matrix, msg='cost matrix') + indexes = m.compute(cost_matrix) + total_cost = 0 + for r, c in indexes: + x = cost_matrix[r][c] + total_cost += x + print('(%d, %d) -> %d' % (r, c, x)) + print('lowest cost=%d' % total_cost) + assert expected_total == total_cost + diff --git a/v2x/AB3DMOT_plugin/scripts/__init__.py b/v2x/AB3DMOT_plugin/scripts/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/v2x/AB3DMOT_plugin/scripts/post_processing/__init__.py b/v2x/AB3DMOT_plugin/scripts/post_processing/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/v2x/AB3DMOT_plugin/scripts/post_processing/__pycache__/__init__.cpython-38.pyc b/v2x/AB3DMOT_plugin/scripts/post_processing/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000..36cebd9 Binary files /dev/null and b/v2x/AB3DMOT_plugin/scripts/post_processing/__pycache__/__init__.cpython-38.pyc differ diff --git a/v2x/AB3DMOT_plugin/scripts/post_processing/combine_trk_cat.py b/v2x/AB3DMOT_plugin/scripts/post_processing/combine_trk_cat.py new file mode 100755 index 0000000..e615c41 --- /dev/null +++ b/v2x/AB3DMOT_plugin/scripts/post_processing/combine_trk_cat.py @@ -0,0 +1,74 @@ +# Author: Xinshuo Weng +# email: xinshuo.weng@gmail.com + +# combine tracking results from different categories + +import os, argparse +from AB3DMOT_libs.io import combine_files +from AB3DMOT_libs.utils import find_all_frames, get_subfolder_seq, Config +from xinshuo_io import mkdir_if_missing, is_path_exists + +def parse_args(): + parser = argparse.ArgumentParser(description='AB3DMOT') + parser.add_argument('--det_name', type=str, default='pointrcnn', help='we provide pointrcnn on KITTI, megvii for nuScenes') + parser.add_argument('--dataset', type=str, default='KITTI', help='nuScenes, KITTI') + parser.add_argument('--split', type=str, default='val', help='train, val, test') + parser.add_argument('--suffix', type=str, default='H1', help='additional string of the folder to be combined') + parser.add_argument('--num_hypo', type=int, default=1, help='number of hypothesis to combine') + args = parser.parse_args() + return args + +def combine_trk_cat(split, dataset, method, suffix, num_hypo,split_data_path,root_dir): + # load dataset-specific config + print('root_dir: ',root_dir) + + _, det_id2str, _, seq_list, _ = get_subfolder_seq(dataset, split,split_data_path) + + # load config files + file_path = os.path.dirname(os.path.realpath(__file__)) + config_path = os.path.join(file_path, '../../configs/%s.yml' % dataset) + cfg, _ = Config(config_path) + log = os.path.join(root_dir, '%s_%s_%s' % (method, split, suffix), 'combine_log.txt') + mkdir_if_missing(log); log = open(log, 'w+') + + # source directory + subset = ['%s_%s_%s_%s' % (method, cat, split, suffix) for cat in cfg.cat_list] + + # loop through all hypotheses + for hypo_index in range(num_hypo): + data_suffix = '_%d' % hypo_index + frame_dict = find_all_frames(root_dir, subset, data_suffix, seq_list) + + ############ merge for 3D MOT evaluation + save_root = os.path.join(root_dir, '%s_%s_%s' % (method, split, suffix), 'data'+data_suffix); mkdir_if_missing(save_root) + for seq_tmp in seq_list: + file_list_tmp = list() + + # loop through each category + for subset_tmp in subset: + file_tmp = os.path.join(root_dir, subset_tmp, 'data'+data_suffix, seq_tmp+'.txt') + file_list_tmp.append(file_tmp) + + save_path_tmp = os.path.join(save_root, seq_tmp+'.txt') + combine_files(file_list_tmp, save_path_tmp) + + ############ merge for trk_withid, for detection evaluation and 3D MOT visualization + save_root = os.path.join(root_dir, '%s_%s_%s' % (method, split, suffix), 'trk_withid'+data_suffix) + for seq_tmp in seq_list: + + if seq_tmp not in frame_dict: + continue + + save_dir = os.path.join(save_root, seq_tmp); mkdir_if_missing(save_dir) + for frame_tmp in frame_dict[seq_tmp]: + file_list_tmp = list() + for subset_tmp in subset: + file_tmp = os.path.join(root_dir, subset_tmp, 'trk_withid'+data_suffix, seq_tmp, frame_tmp+'.txt') + if is_path_exists(file_tmp): file_list_tmp.append(file_tmp) + + save_path_tmp = os.path.join(save_dir, frame_tmp+'.txt') + combine_files(file_list_tmp, save_path_tmp, sort=False) + +if __name__ == '__main__': + args = parse_args() + combine_trk_cat(args.split, args.dataset, args.det_name, args.suffix, args.num_hypo) \ No newline at end of file diff --git a/v2x/eval_tracking.py b/v2x/eval_tracking.py new file mode 100644 index 0000000..f0f8418 --- /dev/null +++ b/v2x/eval_tracking.py @@ -0,0 +1,80 @@ +import argparse +import os +from v2x_utils.gen_eval_tracking_data import convert_gt_label, convert_track_label +from AB3DMOT_plugin.scripts.KITTI.evaluate import evaluate +from AB3DMOT_plugin.scripts.KITTI.mailpy import Mail + + +def parse_arguments(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--track-eval-gt-path", type=str, help="Path to ground truth for V2X-Seq-SPD track evaluation in KITTI format" + ) + parser.add_argument( + "--track-results-path", type=str, help="Path to tracking results" + ) + parser.add_argument( + "--track-eval-output-path", type=str, help="Path to tracking evaluation results" + ) + parser.add_argument( + "--ab3dmot-path", type=str, default="AB3DMOT_plugin", help="Path to AB3DMOT" + ) + parser.add_argument( + "--fusion-method", + type=str, + choices=["early_fusion", "middle_fusion", "late_fusion", "ffnet", "veh_only", "inf_only"], + help="Model type", + ) + parser.add_argument('--split', type=str, default='val', help='train, val, test') + parser.add_argument('--det-name', type=str, default='imvoxelnet', help='imvoxelnet') + parser.add_argument('--cat', type=str, default='Car', help='category of running tracking') + parser.add_argument( + "--tvt", + nargs="+", + type=str, + default=["validation"], + choices=["training", "validation", "testing"], + help="Train, validation, or test", + ) + return parser.parse_args() + + +def main(args): + extended_range = [0, -39.68, -3, 100, 39.68, 1] + file_type = f'{args.det_name}_{args.cat}_{args.split}_H1' + for tvt in args.tvt: + print("Track evaluation") + # 生成eval格式ground truth label及val_dic_new_frame2id_frame.json + kitti_track_tvt_path = os.path.join(args.track_eval_gt_path, "cooperative", tvt) + print("generate eval gt label") + dict_seq_frame2id = convert_gt_label(kitti_track_tvt_path, args.ab3dmot_path, extended_range) + + # 生成eval格式track label + print("Convert track result") + track_results_path = f'{args.track_results_path}/{file_type}/data_0' + ab3dmot_results_dir = f'{args.ab3dmot_path}/results/KITTI/{file_type}/data_0' + convert_track_label(track_results_path, ab3dmot_results_dir, dict_seq_frame2id, extended_range) + + # get unique sha key of submitted results + num_hypo = "1" + dimension = "3D" + thres = 0.25 + mail = Mail("") + # + + if dimension == '2D': + eval_3diou, eval_2diou = False, True # eval 2d + elif dimension == '3D': + eval_3diou, eval_2diou = True, False # eval 3d + else: + eval_3diou, eval_2diou = True, False # eval 3d + + # evaluate results + success = evaluate(file_type, mail, num_hypo, eval_3diou, eval_2diou, thres) + + os.system(f'mv {args.ab3dmot_path}/results/KITTI/{file_type} {args.track_eval_output_path}') + + +if __name__ == "__main__": + args = parse_arguments() + main(args) diff --git a/v2x/scripts/eval_camera_ab3dmot_spd.sh b/v2x/scripts/eval_camera_ab3dmot_spd.sh new file mode 100644 index 0000000..2d906b0 --- /dev/null +++ b/v2x/scripts/eval_camera_ab3dmot_spd.sh @@ -0,0 +1,46 @@ +#Tracking +DET_OUTPUT=$1 + +SPLIT_DATA_PATH="../data/split_datas/cooperative-split-data-spd.json" +DATASET='KITTI' +SPLIT='val' +TYPE='Car' +DETNAME='imvoxelnet' +EVAL_RESULT_NAME='spd_late_camera' + +#Convert detection results to KITTI format +OUTPUT_PATH_DTC="../output/${EVAL_RESULT_NAME}/detection_results_to_kitti" +OUTPUT_PATH_DTC_SUB="${OUTPUT_PATH_DTC}/${DETNAME}_${TYPE}_${SPLIT}" + +mkdir -p $OUTPUT_PATH_DTC_SUB +python ../tools/dataset_converter/label_det_result2kitti.py \ + --input-dir-path ${DET_OUTPUT}/result \ + --output-dir-path ${OUTPUT_PATH_DTC_SUB} \ + --spd-path ../data/V2X-Seq-SPD + +#AB3DMOT +INPUT_PATH_TRACK=$OUTPUT_PATH_DTC +OUTPUT_PATH_TRACK="../output/${EVAL_RESULT_NAME}/tracking_results_to_kitti" + +mkdir -p $OUTPUT_PATH_TRACK +python AB3DMOT_plugin/main_tracking.py \ + --dataset $DATASET \ + --split $SPLIT \ + --det_name $DETNAME \ + --cat $TYPE \ + --split-data-path $SPLIT_DATA_PATH \ + --input-path $INPUT_PATH_TRACK \ + --output-path $OUTPUT_PATH_TRACK + +#Eval +TRACK_EVAL_GT_PATH="../data/V2X-Seq-SPD-KITTI" +TRACK_EVAL_OUTPUT_PATH="../output/${EVAL_RESULT_NAME}/tracking_evaluation_results" +FUSION_METHOD="late_fusion" +python eval_tracking.py \ + --track-eval-gt-path $TRACK_EVAL_GT_PATH \ + --track-results-path $OUTPUT_PATH_TRACK \ + --track-eval-output-path $TRACK_EVAL_OUTPUT_PATH \ + --split $SPLIT \ + --det-name $DETNAME \ + --cat $TYPE \ + --fusion-method $FUSION_METHOD \ diff --git a/v2x/scripts/eval_camera_late_fusion_imvoxelnet_spd.sh b/v2x/scripts/eval_camera_late_fusion_imvoxelnet_spd.sh new file mode 100644 index 0000000..fb09439 --- /dev/null +++ b/v2x/scripts/eval_camera_late_fusion_imvoxelnet_spd.sh @@ -0,0 +1,39 @@ +CUDA_VISIBLE_DEVICES=$1 +FUSION_METHOD=$2 +DELAY_K=$3 +EXTEND_RANGE_START=$4 +EXTEND_RANGE_END=$5 +TIME_COMPENSATION=$6 +OUTPUT=$7 + +DATA="../data/V2X-Seq-SPD" + +INFRA_MODEL_PATH="../configs/vic3d-spd/late-fusion-image/imvoxelnet" +INFRA_CONFIG_NAME="trainval_config_i.py" +INFRA_MODEL_NAME="vic3d_latefusion_imvoxelnet_i.pth" + +VEHICLE_MODEL_PATH="../configs/vic3d-spd/late-fusion-image/imvoxelnet" +VEHICLE_CONFIG_NAME="trainval_config_v.py" +VEHICLE_MODEL_NAME="vic3d_latefusion_imvoxelnet_v.pth" + +SPLIT_DATA_PATH="../data/split_datas/cooperative-split-data-spd.json" + +python eval.py \ + --input $DATA \ + --output $OUTPUT \ + --model $FUSION_METHOD \ + --dataset vic-async-spd \ + --k $DELAY_K \ + --split val \ + --split-data-path $SPLIT_DATA_PATH \ + --inf-config-path $INFRA_MODEL_PATH/$INFRA_CONFIG_NAME \ + --inf-model-path $INFRA_MODEL_PATH/$INFRA_MODEL_NAME \ + --veh-config-path $VEHICLE_MODEL_PATH/$VEHICLE_CONFIG_NAME \ + --veh-model-path $VEHICLE_MODEL_PATH/${VEHICLE_MODEL_NAME} \ + --device ${CUDA_VISIBLE_DEVICES} \ + --pred-class car \ + --sensortype camera \ + --extended-range $EXTEND_RANGE_START -39.68 -3 $EXTEND_RANGE_END 39.68 1 \ + --overwrite-cache \ + $TIME_COMPENSATION + diff --git a/v2x/scripts/eval_camera_late_fusion_spd.sh b/v2x/scripts/eval_camera_late_fusion_spd.sh new file mode 100644 index 0000000..2493091 --- /dev/null +++ b/v2x/scripts/eval_camera_late_fusion_spd.sh @@ -0,0 +1,25 @@ +CUDA_VISIBLE_DEVICES=$1 +DELAY_K=$2 +EXTEND_RANGE_START=$3 +EXTEND_RANGE_END=$4 +TIME_COMPENSATION=$5 +ONLY_DTC=$6 + +#Detection +DET_OUTPUT="../output/spd_late_camera/detection_results/" +if [ -d "$DET_OUTPUT" ]; then + rm -r $DET_OUTPUT +fi + +mkdir -p $DET_OUTPUT/result +mkdir -p $DET_OUTPUT/inf/camera +mkdir -p $DET_OUTPUT/veh/camera +bash scripts/eval_camera_late_fusion_imvoxelnet_spd.sh \ + $CUDA_VISIBLE_DEVICES 'late_fusion' $DELAY_K $EXTEND_RANGE_START \ + $EXTEND_RANGE_END $TIME_COMPENSATION $DET_OUTPUT + +echo "ONLY_DTC flag: "${ONLY_DTC} +if [ "$ONLY_DTC" != true ]; then + #Tracking + bash scripts/eval_camera_ab3dmot_spd.sh $DET_OUTPUT +fi diff --git a/v2x/v2x_utils/gen_eval_tracking_data/__init__.py b/v2x/v2x_utils/gen_eval_tracking_data/__init__.py new file mode 100644 index 0000000..0beefff --- /dev/null +++ b/v2x/v2x_utils/gen_eval_tracking_data/__init__.py @@ -0,0 +1,2 @@ +from .filter import * +from .convert_dair_kitti2ab3dmot import * diff --git a/v2x/v2x_utils/gen_eval_tracking_data/convert_dair_kitti2ab3dmot.py b/v2x/v2x_utils/gen_eval_tracking_data/convert_dair_kitti2ab3dmot.py new file mode 100644 index 0000000..dbc8f75 --- /dev/null +++ b/v2x/v2x_utils/gen_eval_tracking_data/convert_dair_kitti2ab3dmot.py @@ -0,0 +1,114 @@ +import os +import json +import numpy as np +from .filter import range2box, get_lidar_3d_8points, RectFilter +from rich.progress import track + + +def convert_gt_label(kitti_track_tvt_path, ab3dmot_path, extended_range=None): + """ + v2x/AB3DMOT_plugin/scripts/KITTI/evaluate_tracking.seqmap.val + eval_label_data/full/validation_gt_label -> scripts/KITTI/label/ + Args: + input_path: "cooperative_gt_label/validation_gt_label" + kitti_track_tvt_path: "../../data/V2X-Seq-SPD-KITTI/cooperative/validation" + ab3dmot_path: "./AB3DMOT_plugin" + output_path: "eval_label_data/full/validation_gt_label" + Returns: + dict + """ + if extended_range is None: + extended_range = [0, -39.68, -3, 100, 39.68, 1] + bbox_filter = RectFilter(range2box(np.array(extended_range))[0]) + + seqmap_file_path = os.path.join(ab3dmot_path, 'scripts/KITTI/evaluate_tracking.seqmap.val') + output_path = os.path.join(ab3dmot_path, 'scripts/KITTI/label') + + os.system(f'rm {seqmap_file_path}') + os.makedirs(output_path, exist_ok=True) + os.system(f'rm -rf {output_path}/*') + + dic_data_json = {} + list_sequence_files = sorted(os.listdir(kitti_track_tvt_path)) + with open(seqmap_file_path, 'w') as a: + for sequence_file in track(list_sequence_files): + b = [sequence_file.split('.')[0], "empty", "000000"] + input_seq_file_path = f'{kitti_track_tvt_path}/{sequence_file}/label_02/{sequence_file}.txt' + output_seq_file_path = f'{output_path}/{sequence_file}.txt' + with open(input_seq_file_path, 'r') as read_f, open(output_seq_file_path, "w") as write_f: + list_lines = read_f.readlines() + list_lines_filt = [] + for line in list_lines: + line = line.replace("Truck", "Car") + line = line.replace("Van", "Car") + line = line.replace("Bus", "Car") + i = line.strip().split(' ') + corners = get_lidar_3d_8points([float(i[12]), float(i[11]), float(i[10])], [float(i[17]), float(i[18]), float(i[19])], + float(i[20])) + if bbox_filter(corners): + list_lines_filt.append(line) + + list_frame = [] + for i in list_lines_filt: + list_i = i.strip("\n").split(" ") + if list_i[0] not in list_frame: + list_frame.append(list_i[0]) + dic_frame2id = {k: str(j) for j, k in enumerate(list_frame)} + dic_data_json[b[0]] = dic_frame2id + len_frame = len(list_frame) + b.append(f"{len_frame:06d}\n") + a.write(' '.join(b)) + for line in list_lines_filt: + list_line = line.strip("\n").split(" ") + list_line[0] = dic_frame2id[list_line[0]] + list_line_output = [list_line[0], "{:.0f}".format(float(list_line[2])), list_line[1], list_line[3], list_line[4], + list_line[5], list_line[6], list_line[7], list_line[8], list_line[9], list_line[10], list_line[11], + list_line[12], list_line[13], list_line[14], list_line[15], list_line[16]] + str_line = ' '.join(list_line_output) + '\n' + write_f.write(str_line) + return dic_data_json + + +def convert_track_label(track_results_path, output_path, dic, extended_range=None): + """ + Args: + track_results_path: "../output/${EVAL_RESULT_NAME}/tracking_results_to_kitti/${SUB_OUTPUT_PATH_DTC}_H1/data_0" + output_path: ./AB3DMOT_plugin/results/KITTI/imvoxelnet_Car_val_H1/data_0 + dic: dict from val_dic_new_frame2id_frame.json + extended_range: [0, -39.68, -3, 100, 39.68, 1] + Returns: + None + """ + if extended_range is None: + extended_range = [0, -39.68, -3, 100, 39.68, 1] + bbox_filter = RectFilter(range2box(np.array(extended_range))[0]) + os.makedirs(output_path, exist_ok=True) + os.system(f'rm -rf {output_path}/*') + list_sequence_files = sorted(os.listdir(track_results_path)) + for sequence_file in track(list_sequence_files): + dic_frame2id = dic[sequence_file.split('.')[0]] + input_seq_file_path = os.path.join(track_results_path, sequence_file) + output_seq_file_path = os.path.join(output_path, sequence_file) + with open(input_seq_file_path, 'r') as read_f, open(output_seq_file_path, "w") as write_f: + list_lines = read_f.readlines() + list_lines_filt = [] + for line in list_lines: + line = line.replace("Truck", "Car") + line = line.replace("Van", "Car") + line = line.replace("Bus", "Car") + i = line.strip().split(' ') + corners = get_lidar_3d_8points([float(i[12]), float(i[11]), float(i[10])], [float(i[17]), float(i[18]), float(i[19])], float(i[20])) + if bbox_filter(corners): + list_lines_filt.append(line) + + for line in list_lines_filt: + list_line = line.strip("\n").split(" ") + if list_line[0] not in dic_frame2id.keys(): + # print(sequence_file, list_line[0]) + continue + list_line[0] = dic_frame2id[list_line[0]] + list_line_output = [list_line[0], str(int(list_line[2])), list_line[1], list_line[3], list_line[4], list_line[5], + list_line[6], list_line[7], list_line[8], list_line[9], list_line[10], list_line[11], list_line[12], + list_line[13], list_line[14], list_line[15], list_line[16], list_line[23]] + str_line = ' '.join(list_line_output) + '\n' + write_f.write(str_line) diff --git a/v2x/v2x_utils/gen_eval_tracking_data/filter.py b/v2x/v2x_utils/gen_eval_tracking_data/filter.py new file mode 100644 index 0000000..03628dc --- /dev/null +++ b/v2x/v2x_utils/gen_eval_tracking_data/filter.py @@ -0,0 +1,116 @@ +import math +import numpy as np + + +def range2box(box_range): + # [x0, y0, z0, x1, y1, z1] + box_range = np.array(box_range) + indexs = [ + [0, 1, 2], + [3, 1, 2], + [3, 4, 2], + [0, 4, 2], + [0, 1, 5], + [3, 1, 5], + [3, 4, 5], + [0, 4, 5], + ] + return np.array([[box_range[index] for index in indexs]]) + + +def dot_product(p1, p2): + return p1[0] * p2[0] + p1[1] * p2[1] + p1[2] * p2[2] + + +def GetCross(x1, y1, x2, y2, x, y): + a = (x2 - x1, y2 - y1) + b = (x - x1, y - y1) + return a[0] * b[1] - a[1] * b[0] + + +def cross_product(p1, p2): + return [ + p1[1] * p2[2] - p1[2] * p2[1], + p1[2] * p2[0] - p1[0] * p2[2], + p1[0] * p2[1] - p2[0] * p1[1], + ] + + +def isInSide(x1, y1, x2, y2, x3, y3, x4, y4, x, y): + return ( + GetCross(x1, y1, x2, y2, x, y) * GetCross(x3, y3, x4, y4, x, y) >= 0 + and GetCross(x2, y2, x3, y3, x, y) * GetCross(x4, y4, x1, y1, x, y) >= 0 + ) + + +def above_plane(point, plane): + # ax + by + cz = d + norm = cross_product(plane[1] - plane[0], plane[2] - plane[0]) # [a, b, c] + d = dot_product(plane[0], norm) + z_intersec = (d - norm[0] * point[0] - norm[1] * point[1]) / norm[2] + # https://www.cnblogs.com/nobodyzhou/p/6145030.html + t = (norm[0] * point[0] + norm[1] * point[1] + norm[2] * point[2] - d) / ( + norm[0] ** 2 + norm[1] ** 2 + norm[2] ** 2 + ) + point_x = point[0] - norm[0] * t + point_y = point[1] - norm[1] * t + if z_intersec <= point[2] and isInSide( + plane[0][0], + plane[0][1], + plane[1][0], + plane[1][1], + plane[2][0], + plane[2][1], + plane[3][0], + plane[3][1], + point_x, + point_y, + ): + # if z_intersec <= point[2] and point_in_matrix([point_x,point_y], plane[:, :2]): + return 1 + else: + return 0 + + +def point_in_box(point, box): + return above_plane(point, box[:4]) + above_plane(point, box[4:]) == 1 + + +def get_lidar_3d_8points(label_3d_dimensions, lidar_3d_location, rotation_z): + lidar_rotation = np.matrix( + [ + [math.cos(rotation_z), -math.sin(rotation_z), 0], + [math.sin(rotation_z), math.cos(rotation_z), 0], + [0, 0, 1] + ] + ) + l, w, h = label_3d_dimensions + corners_3d_lidar = np.matrix( + [ + [l / 2, l / 2, -l / 2, -l / 2, l / 2, l / 2, -l / 2, -l / 2], + [w / 2, -w / 2, -w / 2, w / 2, w / 2, -w / 2, -w / 2, w / 2], + [-h / 2, -h / 2, -h / 2, -h / 2, h / 2, h / 2, h / 2, h / 2], + ] + ) + lidar_3d_8points = lidar_rotation * corners_3d_lidar + np.matrix(lidar_3d_location).T + return lidar_3d_8points.T.tolist() + + +class Filter(object): + def __init__(self): + pass + + def __call__(self, **args): + return True + + +class RectFilter(Filter): + def __init__(self, bbox): + super().__init__() + self.bbox = bbox + + def __call__(self, box, **args): + for corner in box: + if point_in_box(corner, self.bbox): + return True + return False \ No newline at end of file