Repository: sshaoshuai/Pointnet2.PyTorch
Branch: master
Commit: fce17c2a2df2
Files: 30
Total size: 234.3 KB

Directory structure:
gitextract__re0lvaz/

├── .gitignore
├── LICENSE
├── README.md
├── pointnet2/
│   ├── pointnet2_modules.py
│   ├── pointnet2_utils.py
│   ├── pytorch_utils.py
│   ├── setup.py
│   └── src/
│       ├── ball_query.cpp
│       ├── ball_query_gpu.cu
│       ├── ball_query_gpu.h
│       ├── cuda_utils.h
│       ├── group_points.cpp
│       ├── group_points_gpu.cu
│       ├── group_points_gpu.h
│       ├── interpolate.cpp
│       ├── interpolate_gpu.cu
│       ├── interpolate_gpu.h
│       ├── pointnet2_api.cpp
│       ├── sampling.cpp
│       ├── sampling_gpu.cu
│       └── sampling_gpu.h
└── tools/
    ├── _init_path.py
    ├── data/
    │   └── KITTI/
    │       └── ImageSets/
    │           ├── test.txt
    │           ├── train.txt
    │           ├── trainval.txt
    │           └── val.txt
    ├── dataset.py
    ├── kitti_utils.py
    ├── pointnet2_msg.py
    └── train_and_eval.py

================================================
FILE CONTENTS
================================================

================================================
FILE: .gitignore
================================================
pointnet2/build/
pointnet2/dist/
pointnet2/pointnet2.egg-info/
__pycache__/


================================================
FILE: LICENSE
================================================
MIT License

Copyright (c) 2019 Shaoshuai Shi

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


================================================
FILE: README.md
================================================
# Pointnet2.PyTorch

* PyTorch implementation of [PointNet++](https://arxiv.org/abs/1706.02413) based on [erikwijmans/Pointnet2_PyTorch](https://github.com/erikwijmans/Pointnet2_PyTorch).
* Faster than the original codes by re-implementing the CUDA operations. 

## Installation
### Requirements
* Linux (tested on Ubuntu 14.04/16.04)
* Python 3.6+
* PyTorch 1.0

### Install 
Install this library by running the following command:

```shell
cd pointnet2
python setup.py install
cd ../
```

## Examples
Here I provide a simple example to use this library in the task of KITTI ourdoor foreground point cloud segmentation, and you could refer to the paper [PointRCNN](https://arxiv.org/abs/1812.04244) for the details of task description and foreground label generation.

1. Download the training data from [KITTI 3D object detection](http://www.cvlibs.net/datasets/kitti/eval_object.php?obj_benchmark=3d) website and organize the downloaded files as follows:
```
Pointnet2.PyTorch
├── pointnet2
├── tools
│   ├──data
│   │  ├── KITTI
│   │  │   ├── ImageSets
│   │  │   ├── object
│   │  │   │   ├──training
│   │  │   │      ├──calib & velodyne & label_2 & image_2
│   │  train_and_eval.py
```

2. Run the following command to train and evaluate:
```shell
cd tools
python train_and_eval.py --batch_size 8 --epochs 100 --ckpt_save_interval 2 
```



## Project using this repo:
* [PointRCNN](https://github.com/sshaoshuai/PointRCNN): 3D object detector from raw point cloud.

## Acknowledgement
* [charlesq34/pointnet2](https://github.com/charlesq34/pointnet2): Paper author and official code repo.
* [erikwijmans/Pointnet2_PyTorch](https://github.com/erikwijmans/Pointnet2_PyTorch): Initial work of PyTorch implementation of PointNet++. 


================================================
FILE: pointnet2/pointnet2_modules.py
================================================
import torch
import torch.nn as nn
import torch.nn.functional as F

from . import pointnet2_utils
from . import pytorch_utils as pt_utils
from typing import List


class _PointnetSAModuleBase(nn.Module):

    def __init__(self):
        super().__init__()
        self.npoint = None
        self.groupers = None
        self.mlps = None
        self.pool_method = 'max_pool'

    def forward(self, xyz: torch.Tensor, features: torch.Tensor = None, new_xyz=None) -> (torch.Tensor, torch.Tensor):
        """
        :param xyz: (B, N, 3) tensor of the xyz coordinates of the features
        :param features: (B, N, C) tensor of the descriptors of the the features
        :param new_xyz:
        :return:
            new_xyz: (B, npoint, 3) tensor of the new features' xyz
            new_features: (B, npoint, \sum_k(mlps[k][-1])) tensor of the new_features descriptors
        """
        new_features_list = []

        xyz_flipped = xyz.transpose(1, 2).contiguous()
        if new_xyz is None:
            new_xyz = pointnet2_utils.gather_operation(
                xyz_flipped,
                pointnet2_utils.furthest_point_sample(xyz, self.npoint)
            ).transpose(1, 2).contiguous() if self.npoint is not None else None

        for i in range(len(self.groupers)):
            new_features = self.groupers[i](xyz, new_xyz, features)  # (B, C, npoint, nsample)

            new_features = self.mlps[i](new_features)  # (B, mlp[-1], npoint, nsample)
            if self.pool_method == 'max_pool':
                new_features = F.max_pool2d(
                    new_features, kernel_size=[1, new_features.size(3)]
                )  # (B, mlp[-1], npoint, 1)
            elif self.pool_method == 'avg_pool':
                new_features = F.avg_pool2d(
                    new_features, kernel_size=[1, new_features.size(3)]
                )  # (B, mlp[-1], npoint, 1)
            else:
                raise NotImplementedError

            new_features = new_features.squeeze(-1)  # (B, mlp[-1], npoint)
            new_features_list.append(new_features)

        return new_xyz, torch.cat(new_features_list, dim=1)


class PointnetSAModuleMSG(_PointnetSAModuleBase):
    """Pointnet set abstraction layer with multiscale grouping"""

    def __init__(self, *, npoint: int, radii: List[float], nsamples: List[int], mlps: List[List[int]], bn: bool = True,
                 use_xyz: bool = True, pool_method='max_pool', instance_norm=False):
        """
        :param npoint: int
        :param radii: list of float, list of radii to group with
        :param nsamples: list of int, number of samples in each ball query
        :param mlps: list of list of int, spec of the pointnet before the global pooling for each scale
        :param bn: whether to use batchnorm
        :param use_xyz:
        :param pool_method: max_pool / avg_pool
        :param instance_norm: whether to use instance_norm
        """
        super().__init__()

        assert len(radii) == len(nsamples) == len(mlps)

        self.npoint = npoint
        self.groupers = nn.ModuleList()
        self.mlps = nn.ModuleList()
        for i in range(len(radii)):
            radius = radii[i]
            nsample = nsamples[i]
            self.groupers.append(
                pointnet2_utils.QueryAndGroup(radius, nsample, use_xyz=use_xyz)
                if npoint is not None else pointnet2_utils.GroupAll(use_xyz)
            )
            mlp_spec = mlps[i]
            if use_xyz:
                mlp_spec[0] += 3

            self.mlps.append(pt_utils.SharedMLP(mlp_spec, bn=bn, instance_norm=instance_norm))
        self.pool_method = pool_method


class PointnetSAModule(PointnetSAModuleMSG):
    """Pointnet set abstraction layer"""

    def __init__(self, *, mlp: List[int], npoint: int = None, radius: float = None, nsample: int = None,
                 bn: bool = True, use_xyz: bool = True, pool_method='max_pool', instance_norm=False):
        """
        :param mlp: list of int, spec of the pointnet before the global max_pool
        :param npoint: int, number of features
        :param radius: float, radius of ball
        :param nsample: int, number of samples in the ball query
        :param bn: whether to use batchnorm
        :param use_xyz:
        :param pool_method: max_pool / avg_pool
        :param instance_norm: whether to use instance_norm
        """
        super().__init__(
            mlps=[mlp], npoint=npoint, radii=[radius], nsamples=[nsample], bn=bn, use_xyz=use_xyz,
            pool_method=pool_method, instance_norm=instance_norm
        )


class PointnetFPModule(nn.Module):
    r"""Propigates the features of one set to another"""

    def __init__(self, *, mlp: List[int], bn: bool = True):
        """
        :param mlp: list of int
        :param bn: whether to use batchnorm
        """
        super().__init__()
        self.mlp = pt_utils.SharedMLP(mlp, bn=bn)

    def forward(
            self, unknown: torch.Tensor, known: torch.Tensor, unknow_feats: torch.Tensor, known_feats: torch.Tensor
    ) -> torch.Tensor:
        """
        :param unknown: (B, n, 3) tensor of the xyz positions of the unknown features
        :param known: (B, m, 3) tensor of the xyz positions of the known features
        :param unknow_feats: (B, C1, n) tensor of the features to be propigated to
        :param known_feats: (B, C2, m) tensor of features to be propigated
        :return:
            new_features: (B, mlp[-1], n) tensor of the features of the unknown features
        """
        if known is not None:
            dist, idx = pointnet2_utils.three_nn(unknown, known)
            dist_recip = 1.0 / (dist + 1e-8)
            norm = torch.sum(dist_recip, dim=2, keepdim=True)
            weight = dist_recip / norm

            interpolated_feats = pointnet2_utils.three_interpolate(known_feats, idx, weight)
        else:
            interpolated_feats = known_feats.expand(*known_feats.size()[0:2], unknown.size(1))

        if unknow_feats is not None:
            new_features = torch.cat([interpolated_feats, unknow_feats], dim=1)  # (B, C2 + C1, n)
        else:
            new_features = interpolated_feats

        new_features = new_features.unsqueeze(-1)
        new_features = self.mlp(new_features)

        return new_features.squeeze(-1)


if __name__ == "__main__":
    pass


================================================
FILE: pointnet2/pointnet2_utils.py
================================================
import torch
from torch.autograd import Variable
from torch.autograd import Function
import torch.nn as nn
from typing import Tuple

import pointnet2_cuda as pointnet2


class FurthestPointSampling(Function):
    @staticmethod
    def forward(ctx, xyz: torch.Tensor, npoint: int) -> torch.Tensor:
        """
        Uses iterative furthest point sampling to select a set of npoint features that have the largest
        minimum distance
        :param ctx:
        :param xyz: (B, N, 3) where N > npoint
        :param npoint: int, number of features in the sampled set
        :return:
             output: (B, npoint) tensor containing the set
        """
        assert xyz.is_contiguous()

        B, N, _ = xyz.size()
        output = torch.cuda.IntTensor(B, npoint)
        temp = torch.cuda.FloatTensor(B, N).fill_(1e10)

        pointnet2.furthest_point_sampling_wrapper(B, N, npoint, xyz, temp, output)
        return output

    @staticmethod
    def backward(xyz, a=None):
        return None, None


furthest_point_sample = FurthestPointSampling.apply


class GatherOperation(Function):

    @staticmethod
    def forward(ctx, features: torch.Tensor, idx: torch.Tensor) -> torch.Tensor:
        """
        :param ctx:
        :param features: (B, C, N)
        :param idx: (B, npoint) index tensor of the features to gather
        :return:
            output: (B, C, npoint)
        """
        assert features.is_contiguous()
        assert idx.is_contiguous()

        B, npoint = idx.size()
        _, C, N = features.size()
        output = torch.cuda.FloatTensor(B, C, npoint)

        pointnet2.gather_points_wrapper(B, C, N, npoint, features, idx, output)

        ctx.for_backwards = (idx, C, N)
        return output

    @staticmethod
    def backward(ctx, grad_out):
        idx, C, N = ctx.for_backwards
        B, npoint = idx.size()

        grad_features = Variable(torch.cuda.FloatTensor(B, C, N).zero_())
        grad_out_data = grad_out.data.contiguous()
        pointnet2.gather_points_grad_wrapper(B, C, N, npoint, grad_out_data, idx, grad_features.data)
        return grad_features, None


gather_operation = GatherOperation.apply


class ThreeNN(Function):

    @staticmethod
    def forward(ctx, unknown: torch.Tensor, known: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
        """
        Find the three nearest neighbors of unknown in known
        :param ctx:
        :param unknown: (B, N, 3)
        :param known: (B, M, 3)
        :return:
            dist: (B, N, 3) l2 distance to the three nearest neighbors
            idx: (B, N, 3) index of 3 nearest neighbors
        """
        assert unknown.is_contiguous()
        assert known.is_contiguous()

        B, N, _ = unknown.size()
        m = known.size(1)
        dist2 = torch.cuda.FloatTensor(B, N, 3)
        idx = torch.cuda.IntTensor(B, N, 3)

        pointnet2.three_nn_wrapper(B, N, m, unknown, known, dist2, idx)
        return torch.sqrt(dist2), idx

    @staticmethod
    def backward(ctx, a=None, b=None):
        return None, None


three_nn = ThreeNN.apply


class ThreeInterpolate(Function):

    @staticmethod
    def forward(ctx, features: torch.Tensor, idx: torch.Tensor, weight: torch.Tensor) -> torch.Tensor:
        """
        Performs weight linear interpolation on 3 features
        :param ctx:
        :param features: (B, C, M) Features descriptors to be interpolated from
        :param idx: (B, n, 3) three nearest neighbors of the target features in features
        :param weight: (B, n, 3) weights
        :return:
            output: (B, C, N) tensor of the interpolated features
        """
        assert features.is_contiguous()
        assert idx.is_contiguous()
        assert weight.is_contiguous()

        B, c, m = features.size()
        n = idx.size(1)
        ctx.three_interpolate_for_backward = (idx, weight, m)
        output = torch.cuda.FloatTensor(B, c, n)

        pointnet2.three_interpolate_wrapper(B, c, m, n, features, idx, weight, output)
        return output

    @staticmethod
    def backward(ctx, grad_out: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
        """
        :param ctx:
        :param grad_out: (B, C, N) tensor with gradients of outputs
        :return:
            grad_features: (B, C, M) tensor with gradients of features
            None:
            None:
        """
        idx, weight, m = ctx.three_interpolate_for_backward
        B, c, n = grad_out.size()

        grad_features = Variable(torch.cuda.FloatTensor(B, c, m).zero_())
        grad_out_data = grad_out.data.contiguous()

        pointnet2.three_interpolate_grad_wrapper(B, c, n, m, grad_out_data, idx, weight, grad_features.data)
        return grad_features, None, None


three_interpolate = ThreeInterpolate.apply


class GroupingOperation(Function):

    @staticmethod
    def forward(ctx, features: torch.Tensor, idx: torch.Tensor) -> torch.Tensor:
        """
        :param ctx:
        :param features: (B, C, N) tensor of features to group
        :param idx: (B, npoint, nsample) tensor containing the indicies of features to group with
        :return:
            output: (B, C, npoint, nsample) tensor
        """
        assert features.is_contiguous()
        assert idx.is_contiguous()

        B, nfeatures, nsample = idx.size()
        _, C, N = features.size()
        output = torch.cuda.FloatTensor(B, C, nfeatures, nsample)

        pointnet2.group_points_wrapper(B, C, N, nfeatures, nsample, features, idx, output)

        ctx.for_backwards = (idx, N)
        return output

    @staticmethod
    def backward(ctx, grad_out: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
        """
        :param ctx:
        :param grad_out: (B, C, npoint, nsample) tensor of the gradients of the output from forward
        :return:
            grad_features: (B, C, N) gradient of the features
        """
        idx, N = ctx.for_backwards

        B, C, npoint, nsample = grad_out.size()
        grad_features = Variable(torch.cuda.FloatTensor(B, C, N).zero_())

        grad_out_data = grad_out.data.contiguous()
        pointnet2.group_points_grad_wrapper(B, C, N, npoint, nsample, grad_out_data, idx, grad_features.data)
        return grad_features, None


grouping_operation = GroupingOperation.apply


class BallQuery(Function):

    @staticmethod
    def forward(ctx, radius: float, nsample: int, xyz: torch.Tensor, new_xyz: torch.Tensor) -> torch.Tensor:
        """
        :param ctx:
        :param radius: float, radius of the balls
        :param nsample: int, maximum number of features in the balls
        :param xyz: (B, N, 3) xyz coordinates of the features
        :param new_xyz: (B, npoint, 3) centers of the ball query
        :return:
            idx: (B, npoint, nsample) tensor with the indicies of the features that form the query balls
        """
        assert new_xyz.is_contiguous()
        assert xyz.is_contiguous()

        B, N, _ = xyz.size()
        npoint = new_xyz.size(1)
        idx = torch.cuda.IntTensor(B, npoint, nsample).zero_()

        pointnet2.ball_query_wrapper(B, N, npoint, radius, nsample, new_xyz, xyz, idx)
        return idx

    @staticmethod
    def backward(ctx, a=None):
        return None, None, None, None


ball_query = BallQuery.apply


class QueryAndGroup(nn.Module):
    def __init__(self, radius: float, nsample: int, use_xyz: bool = True):
        """
        :param radius: float, radius of ball
        :param nsample: int, maximum number of features to gather in the ball
        :param use_xyz:
        """
        super().__init__()
        self.radius, self.nsample, self.use_xyz = radius, nsample, use_xyz

    def forward(self, xyz: torch.Tensor, new_xyz: torch.Tensor, features: torch.Tensor = None) -> Tuple[torch.Tensor]:
        """
        :param xyz: (B, N, 3) xyz coordinates of the features
        :param new_xyz: (B, npoint, 3) centroids
        :param features: (B, C, N) descriptors of the features
        :return:
            new_features: (B, 3 + C, npoint, nsample)
        """
        idx = ball_query(self.radius, self.nsample, xyz, new_xyz)
        xyz_trans = xyz.transpose(1, 2).contiguous()
        grouped_xyz = grouping_operation(xyz_trans, idx)  # (B, 3, npoint, nsample)
        grouped_xyz -= new_xyz.transpose(1, 2).unsqueeze(-1)

        if features is not None:
            grouped_features = grouping_operation(features, idx)
            if self.use_xyz:
                new_features = torch.cat([grouped_xyz, grouped_features], dim=1)  # (B, C + 3, npoint, nsample)
            else:
                new_features = grouped_features
        else:
            assert self.use_xyz, "Cannot have not features and not use xyz as a feature!"
            new_features = grouped_xyz

        return new_features


class GroupAll(nn.Module):
    def __init__(self, use_xyz: bool = True):
        super().__init__()
        self.use_xyz = use_xyz

    def forward(self, xyz: torch.Tensor, new_xyz: torch.Tensor, features: torch.Tensor = None):
        """
        :param xyz: (B, N, 3) xyz coordinates of the features
        :param new_xyz: ignored
        :param features: (B, C, N) descriptors of the features
        :return:
            new_features: (B, C + 3, 1, N)
        """
        grouped_xyz = xyz.transpose(1, 2).unsqueeze(2)
        if features is not None:
            grouped_features = features.unsqueeze(2)
            if self.use_xyz:
                new_features = torch.cat([grouped_xyz, grouped_features], dim=1)  # (B, 3 + C, 1, N)
            else:
                new_features = grouped_features
        else:
            new_features = grouped_xyz

        return new_features


================================================
FILE: pointnet2/pytorch_utils.py
================================================
import torch.nn as nn
from typing import List, Tuple


class SharedMLP(nn.Sequential):

    def __init__(
            self,
            args: List[int],
            *,
            bn: bool = False,
            activation=nn.ReLU(inplace=True),
            preact: bool = False,
            first: bool = False,
            name: str = "",
            instance_norm: bool = False,
    ):
        super().__init__()

        for i in range(len(args) - 1):
            self.add_module(
                name + 'layer{}'.format(i),
                Conv2d(
                    args[i],
                    args[i + 1],
                    bn=(not first or not preact or (i != 0)) and bn,
                    activation=activation
                    if (not first or not preact or (i != 0)) else None,
                    preact=preact,
                    instance_norm=instance_norm
                )
            )


class _ConvBase(nn.Sequential):

    def __init__(
            self,
            in_size,
            out_size,
            kernel_size,
            stride,
            padding,
            activation,
            bn,
            init,
            conv=None,
            batch_norm=None,
            bias=True,
            preact=False,
            name="",
            instance_norm=False,
            instance_norm_func=None
    ):
        super().__init__()

        bias = bias and (not bn)
        conv_unit = conv(
            in_size,
            out_size,
            kernel_size=kernel_size,
            stride=stride,
            padding=padding,
            bias=bias
        )
        init(conv_unit.weight)
        if bias:
            nn.init.constant_(conv_unit.bias, 0)

        if bn:
            if not preact:
                bn_unit = batch_norm(out_size)
            else:
                bn_unit = batch_norm(in_size)
        if instance_norm:
            if not preact:
                in_unit = instance_norm_func(out_size, affine=False, track_running_stats=False)
            else:
                in_unit = instance_norm_func(in_size, affine=False, track_running_stats=False)

        if preact:
            if bn:
                self.add_module(name + 'bn', bn_unit)

            if activation is not None:
                self.add_module(name + 'activation', activation)

            if not bn and instance_norm:
                self.add_module(name + 'in', in_unit)

        self.add_module(name + 'conv', conv_unit)

        if not preact:
            if bn:
                self.add_module(name + 'bn', bn_unit)

            if activation is not None:
                self.add_module(name + 'activation', activation)

            if not bn and instance_norm:
                self.add_module(name + 'in', in_unit)


class _BNBase(nn.Sequential):

    def __init__(self, in_size, batch_norm=None, name=""):
        super().__init__()
        self.add_module(name + "bn", batch_norm(in_size))

        nn.init.constant_(self[0].weight, 1.0)
        nn.init.constant_(self[0].bias, 0)


class BatchNorm1d(_BNBase):

    def __init__(self, in_size: int, *, name: str = ""):
        super().__init__(in_size, batch_norm=nn.BatchNorm1d, name=name)


class BatchNorm2d(_BNBase):

    def __init__(self, in_size: int, name: str = ""):
        super().__init__(in_size, batch_norm=nn.BatchNorm2d, name=name)


class Conv1d(_ConvBase):

    def __init__(
            self,
            in_size: int,
            out_size: int,
            *,
            kernel_size: int = 1,
            stride: int = 1,
            padding: int = 0,
            activation=nn.ReLU(inplace=True),
            bn: bool = False,
            init=nn.init.kaiming_normal_,
            bias: bool = True,
            preact: bool = False,
            name: str = "",
            instance_norm=False
    ):
        super().__init__(
            in_size,
            out_size,
            kernel_size,
            stride,
            padding,
            activation,
            bn,
            init,
            conv=nn.Conv1d,
            batch_norm=BatchNorm1d,
            bias=bias,
            preact=preact,
            name=name,
            instance_norm=instance_norm,
            instance_norm_func=nn.InstanceNorm1d
        )


class Conv2d(_ConvBase):

    def __init__(
            self,
            in_size: int,
            out_size: int,
            *,
            kernel_size: Tuple[int, int] = (1, 1),
            stride: Tuple[int, int] = (1, 1),
            padding: Tuple[int, int] = (0, 0),
            activation=nn.ReLU(inplace=True),
            bn: bool = False,
            init=nn.init.kaiming_normal_,
            bias: bool = True,
            preact: bool = False,
            name: str = "",
            instance_norm=False
    ):
        super().__init__(
            in_size,
            out_size,
            kernel_size,
            stride,
            padding,
            activation,
            bn,
            init,
            conv=nn.Conv2d,
            batch_norm=BatchNorm2d,
            bias=bias,
            preact=preact,
            name=name,
            instance_norm=instance_norm,
            instance_norm_func=nn.InstanceNorm2d
        )


class FC(nn.Sequential):

    def __init__(
            self,
            in_size: int,
            out_size: int,
            *,
            activation=nn.ReLU(inplace=True),
            bn: bool = False,
            init=None,
            preact: bool = False,
            name: str = ""
    ):
        super().__init__()

        fc = nn.Linear(in_size, out_size, bias=not bn)
        if init is not None:
            init(fc.weight)
        if not bn:
            nn.init.constant(fc.bias, 0)

        if preact:
            if bn:
                self.add_module(name + 'bn', BatchNorm1d(in_size))

            if activation is not None:
                self.add_module(name + 'activation', activation)

        self.add_module(name + 'fc', fc)

        if not preact:
            if bn:
                self.add_module(name + 'bn', BatchNorm1d(out_size))

            if activation is not None:
                self.add_module(name + 'activation', activation)



================================================
FILE: pointnet2/setup.py
================================================
from setuptools import setup
from torch.utils.cpp_extension import BuildExtension, CUDAExtension

setup(
    name='pointnet2',
    ext_modules=[
        CUDAExtension('pointnet2_cuda', [
            'src/pointnet2_api.cpp',
            
            'src/ball_query.cpp', 
            'src/ball_query_gpu.cu',
            'src/group_points.cpp', 
            'src/group_points_gpu.cu',
            'src/interpolate.cpp', 
            'src/interpolate_gpu.cu',
            'src/sampling.cpp', 
            'src/sampling_gpu.cu',
        ],
        extra_compile_args={'cxx': ['-g'],
                            'nvcc': ['-O2']})
    ],
    cmdclass={'build_ext': BuildExtension}
)


================================================
FILE: pointnet2/src/ball_query.cpp
================================================
#include <torch/serialize/tensor.h>
#include <vector>
#include <THC/THC.h>
#include <cuda.h>
#include <cuda_runtime_api.h>
#include "ball_query_gpu.h"

extern THCState *state;

#define CHECK_CUDA(x) AT_CHECK(x.type().is_cuda(), #x, " must be a CUDAtensor ")
#define CHECK_CONTIGUOUS(x) AT_CHECK(x.is_contiguous(), #x, " must be contiguous ")
#define CHECK_INPUT(x) CHECK_CUDA(x);CHECK_CONTIGUOUS(x)

int ball_query_wrapper_fast(int b, int n, int m, float radius, int nsample, 
    at::Tensor new_xyz_tensor, at::Tensor xyz_tensor, at::Tensor idx_tensor) {
    CHECK_INPUT(new_xyz_tensor);
    CHECK_INPUT(xyz_tensor);
    const float *new_xyz = new_xyz_tensor.data<float>();
    const float *xyz = xyz_tensor.data<float>();
    int *idx = idx_tensor.data<int>();
    
    cudaStream_t stream = THCState_getCurrentStream(state);
    ball_query_kernel_launcher_fast(b, n, m, radius, nsample, new_xyz, xyz, idx, stream);
    return 1;
}

================================================
FILE: pointnet2/src/ball_query_gpu.cu
================================================
#include <math.h>
#include <stdio.h>
#include <stdlib.h>

#include "ball_query_gpu.h"
#include "cuda_utils.h"


__global__ void ball_query_kernel_fast(int b, int n, int m, float radius, int nsample, 
    const float *__restrict__ new_xyz, const float *__restrict__ xyz, int *__restrict__ idx) {
    // new_xyz: (B, M, 3)
    // xyz: (B, N, 3)
    // output:
    //      idx: (B, M, nsample)
    int bs_idx = blockIdx.y;
    int pt_idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (bs_idx >= b || pt_idx >= m) return;

    new_xyz += bs_idx * m * 3 + pt_idx * 3;
    xyz += bs_idx * n * 3;
    idx += bs_idx * m * nsample + pt_idx * nsample;

    float radius2 = radius * radius;
    float new_x = new_xyz[0];
    float new_y = new_xyz[1];
    float new_z = new_xyz[2];

    int cnt = 0;
    for (int k = 0; k < n; ++k) {
        float x = xyz[k * 3 + 0];
        float y = xyz[k * 3 + 1];
        float z = xyz[k * 3 + 2];
        float d2 = (new_x - x) * (new_x - x) + (new_y - y) * (new_y - y) + (new_z - z) * (new_z - z);
        if (d2 < radius2){
            if (cnt == 0){
                for (int l = 0; l < nsample; ++l) {
                    idx[l] = k;
                }
            }
            idx[cnt] = k;
            ++cnt;
            if (cnt >= nsample) break;
        }
    }
}


void ball_query_kernel_launcher_fast(int b, int n, int m, float radius, int nsample, \
    const float *new_xyz, const float *xyz, int *idx, cudaStream_t stream) {
    // new_xyz: (B, M, 3)
    // xyz: (B, N, 3)
    // output:
    //      idx: (B, M, nsample)

    cudaError_t err;

    dim3 blocks(DIVUP(m, THREADS_PER_BLOCK), b);  // blockIdx.x(col), blockIdx.y(row)
    dim3 threads(THREADS_PER_BLOCK);

    ball_query_kernel_fast<<<blocks, threads, 0, stream>>>(b, n, m, radius, nsample, new_xyz, xyz, idx);
    // cudaDeviceSynchronize();  // for using printf in kernel function
    err = cudaGetLastError();
    if (cudaSuccess != err) {
        fprintf(stderr, "CUDA kernel failed : %s\n", cudaGetErrorString(err));
        exit(-1);
    }
}

================================================
FILE: pointnet2/src/ball_query_gpu.h
================================================
#ifndef _BALL_QUERY_GPU_H
#define _BALL_QUERY_GPU_H

#include <torch/serialize/tensor.h>
#include <vector>
#include <cuda.h>
#include <cuda_runtime_api.h>

int ball_query_wrapper_fast(int b, int n, int m, float radius, int nsample, 
	at::Tensor new_xyz_tensor, at::Tensor xyz_tensor, at::Tensor idx_tensor);

void ball_query_kernel_launcher_fast(int b, int n, int m, float radius, int nsample, 
	const float *xyz, const float *new_xyz, int *idx, cudaStream_t stream);

#endif


================================================
FILE: pointnet2/src/cuda_utils.h
================================================
#ifndef _CUDA_UTILS_H
#define _CUDA_UTILS_H

#include <cmath>

#define TOTAL_THREADS 1024
#define THREADS_PER_BLOCK 256
#define DIVUP(m,n) ((m) / (n) + ((m) % (n) > 0))

inline int opt_n_threads(int work_size) {
    const int pow_2 = std::log(static_cast<double>(work_size)) / std::log(2.0);

    return max(min(1 << pow_2, TOTAL_THREADS), 1);
}
#endif


================================================
FILE: pointnet2/src/group_points.cpp
================================================
#include <torch/serialize/tensor.h>
#include <cuda.h>
#include <cuda_runtime_api.h>
#include <vector>
#include <THC/THC.h>
#include "group_points_gpu.h"

extern THCState *state;


int group_points_grad_wrapper_fast(int b, int c, int n, int npoints, int nsample, 
    at::Tensor grad_out_tensor, at::Tensor idx_tensor, at::Tensor grad_points_tensor) {

    float *grad_points = grad_points_tensor.data<float>();
    const int *idx = idx_tensor.data<int>();
    const float *grad_out = grad_out_tensor.data<float>();

    cudaStream_t stream = THCState_getCurrentStream(state);

    group_points_grad_kernel_launcher_fast(b, c, n, npoints, nsample, grad_out, idx, grad_points, stream);
    return 1;
}


int group_points_wrapper_fast(int b, int c, int n, int npoints, int nsample, 
    at::Tensor points_tensor, at::Tensor idx_tensor, at::Tensor out_tensor) {

    const float *points = points_tensor.data<float>();
    const int *idx = idx_tensor.data<int>();
    float *out = out_tensor.data<float>();

    cudaStream_t stream = THCState_getCurrentStream(state);

    group_points_kernel_launcher_fast(b, c, n, npoints, nsample, points, idx, out, stream);
    return 1;
}

================================================
FILE: pointnet2/src/group_points_gpu.cu
================================================
#include <stdio.h>
#include <stdlib.h>

#include "cuda_utils.h"
#include "group_points_gpu.h"


__global__ void group_points_grad_kernel_fast(int b, int c, int n, int npoints, int nsample, 
    const float *__restrict__ grad_out, const int *__restrict__ idx, float *__restrict__ grad_points) {
    // grad_out: (B, C, npoints, nsample)
    // idx: (B, npoints, nsample)
    // output:
    //      grad_points: (B, C, N)
    int bs_idx = blockIdx.z;
    int c_idx = blockIdx.y;
    int index = blockIdx.x * blockDim.x + threadIdx.x;
    int pt_idx = index / nsample;
    if (bs_idx >= b || c_idx >= c || pt_idx >= npoints) return;

    int sample_idx = index % nsample;
    grad_out += bs_idx * c * npoints * nsample + c_idx * npoints * nsample + pt_idx * nsample + sample_idx;
    idx += bs_idx * npoints * nsample + pt_idx * nsample + sample_idx; 
    
    atomicAdd(grad_points + bs_idx * c * n + c_idx * n + idx[0] , grad_out[0]);
}

void group_points_grad_kernel_launcher_fast(int b, int c, int n, int npoints, int nsample, 
    const float *grad_out, const int *idx, float *grad_points, cudaStream_t stream) {
    // grad_out: (B, C, npoints, nsample)
    // idx: (B, npoints, nsample)
    // output:
    //      grad_points: (B, C, N)
    cudaError_t err;
    dim3 blocks(DIVUP(npoints * nsample, THREADS_PER_BLOCK), c, b);  // blockIdx.x(col), blockIdx.y(row)
    dim3 threads(THREADS_PER_BLOCK);

    group_points_grad_kernel_fast<<<blocks, threads, 0, stream>>>(b, c, n, npoints, nsample, grad_out, idx, grad_points);

    err = cudaGetLastError();
    if (cudaSuccess != err) {
        fprintf(stderr, "CUDA kernel failed : %s\n", cudaGetErrorString(err));
        exit(-1);
    }
}


__global__ void group_points_kernel_fast(int b, int c, int n, int npoints, int nsample, 
    const float *__restrict__ points, const int *__restrict__ idx, float *__restrict__ out) {
    // points: (B, C, N)
    // idx: (B, npoints, nsample)
    // output:
    //      out: (B, C, npoints, nsample)
    int bs_idx = blockIdx.z;
    int c_idx = blockIdx.y;
    int index = blockIdx.x * blockDim.x + threadIdx.x;
    int pt_idx = index / nsample;
    if (bs_idx >= b || c_idx >= c || pt_idx >= npoints) return;

    int sample_idx = index % nsample;

    idx += bs_idx * npoints * nsample + pt_idx * nsample + sample_idx; 
    int in_idx = bs_idx * c * n + c_idx * n + idx[0];
    int out_idx = bs_idx * c * npoints * nsample + c_idx * npoints * nsample + pt_idx * nsample + sample_idx;

    out[out_idx] = points[in_idx];
}


void group_points_kernel_launcher_fast(int b, int c, int n, int npoints, int nsample, 
    const float *points, const int *idx, float *out, cudaStream_t stream) {
    // points: (B, C, N)
    // idx: (B, npoints, nsample)
    // output:
    //      out: (B, C, npoints, nsample)
    cudaError_t err;
    dim3 blocks(DIVUP(npoints * nsample, THREADS_PER_BLOCK), c, b);  // blockIdx.x(col), blockIdx.y(row)
    dim3 threads(THREADS_PER_BLOCK);

    group_points_kernel_fast<<<blocks, threads, 0, stream>>>(b, c, n, npoints, nsample, points, idx, out);
    // cudaDeviceSynchronize();  // for using printf in kernel function
    err = cudaGetLastError();
    if (cudaSuccess != err) {
        fprintf(stderr, "CUDA kernel failed : %s\n", cudaGetErrorString(err));
        exit(-1);
    }
}


================================================
FILE: pointnet2/src/group_points_gpu.h
================================================
#ifndef _GROUP_POINTS_GPU_H
#define _GROUP_POINTS_GPU_H

#include <torch/serialize/tensor.h>
#include <cuda.h>
#include <cuda_runtime_api.h>
#include <vector>


int group_points_wrapper_fast(int b, int c, int n, int npoints, int nsample, 
    at::Tensor points_tensor, at::Tensor idx_tensor, at::Tensor out_tensor);

void group_points_kernel_launcher_fast(int b, int c, int n, int npoints, int nsample, 
    const float *points, const int *idx, float *out, cudaStream_t stream);

int group_points_grad_wrapper_fast(int b, int c, int n, int npoints, int nsample, 
    at::Tensor grad_out_tensor, at::Tensor idx_tensor, at::Tensor grad_points_tensor);

void group_points_grad_kernel_launcher_fast(int b, int c, int n, int npoints, int nsample, 
    const float *grad_out, const int *idx, float *grad_points, cudaStream_t stream);

#endif


================================================
FILE: pointnet2/src/interpolate.cpp
================================================
#include <torch/serialize/tensor.h>
#include <vector>
#include <THC/THC.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <cuda.h>
#include <cuda_runtime_api.h>
#include "interpolate_gpu.h"

extern THCState *state;


void three_nn_wrapper_fast(int b, int n, int m, at::Tensor unknown_tensor, 
    at::Tensor known_tensor, at::Tensor dist2_tensor, at::Tensor idx_tensor) {
    const float *unknown = unknown_tensor.data<float>();
    const float *known = known_tensor.data<float>();
    float *dist2 = dist2_tensor.data<float>();
    int *idx = idx_tensor.data<int>();

    cudaStream_t stream = THCState_getCurrentStream(state);
    three_nn_kernel_launcher_fast(b, n, m, unknown, known, dist2, idx, stream);
}


void three_interpolate_wrapper_fast(int b, int c, int m, int n,
                         at::Tensor points_tensor,
                         at::Tensor idx_tensor,
                         at::Tensor weight_tensor,
                         at::Tensor out_tensor) {

    const float *points = points_tensor.data<float>();
    const float *weight = weight_tensor.data<float>();
    float *out = out_tensor.data<float>();
    const int *idx = idx_tensor.data<int>();

    cudaStream_t stream = THCState_getCurrentStream(state);
    three_interpolate_kernel_launcher_fast(b, c, m, n, points, idx, weight, out, stream);
}

void three_interpolate_grad_wrapper_fast(int b, int c, int n, int m,
                            at::Tensor grad_out_tensor,
                            at::Tensor idx_tensor,
                            at::Tensor weight_tensor,
                            at::Tensor grad_points_tensor) {

    const float *grad_out = grad_out_tensor.data<float>();
    const float *weight = weight_tensor.data<float>();
    float *grad_points = grad_points_tensor.data<float>();
    const int *idx = idx_tensor.data<int>();

    cudaStream_t stream = THCState_getCurrentStream(state);
    three_interpolate_grad_kernel_launcher_fast(b, c, n, m, grad_out, idx, weight, grad_points, stream);
}

================================================
FILE: pointnet2/src/interpolate_gpu.cu
================================================
#include <math.h>
#include <stdio.h>
#include <stdlib.h>

#include "cuda_utils.h"
#include "interpolate_gpu.h"


__global__ void three_nn_kernel_fast(int b, int n, int m, const float *__restrict__ unknown, 
    const float *__restrict__ known, float *__restrict__ dist2, int *__restrict__ idx) {
    // unknown: (B, N, 3)
    // known: (B, M, 3)
    // output: 
    //      dist2: (B, N, 3)
    //      idx: (B, N, 3)
    
    int bs_idx = blockIdx.y;
    int pt_idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (bs_idx >= b || pt_idx >= n) return;

    unknown += bs_idx * n * 3 + pt_idx * 3;
    known += bs_idx * m * 3;
    dist2 += bs_idx * n * 3 + pt_idx * 3;
    idx += bs_idx * n * 3 + pt_idx * 3;

    float ux = unknown[0];
    float uy = unknown[1];
    float uz = unknown[2];

    double best1 = 1e40, best2 = 1e40, best3 = 1e40;
    int besti1 = 0, besti2 = 0, besti3 = 0;
    for (int k = 0; k < m; ++k) {
        float x = known[k * 3 + 0];
        float y = known[k * 3 + 1];
        float z = known[k * 3 + 2];
        float d = (ux - x) * (ux - x) + (uy - y) * (uy - y) + (uz - z) * (uz - z);
        if (d < best1) {
            best3 = best2; besti3 = besti2;
            best2 = best1; besti2 = besti1;
            best1 = d; besti1 = k;
        } 
        else if (d < best2) {
            best3 = best2; besti3 = besti2;
            best2 = d; besti2 = k;
        } 
        else if (d < best3) {
            best3 = d; besti3 = k;
        }
    }
    dist2[0] = best1; dist2[1] = best2; dist2[2] = best3;
    idx[0] = besti1; idx[1] = besti2; idx[2] = besti3;
}


void three_nn_kernel_launcher_fast(int b, int n, int m, const float *unknown, 
    const float *known, float *dist2, int *idx, cudaStream_t stream) {
    // unknown: (B, N, 3)
    // known: (B, M, 3)
    // output: 
    //      dist2: (B, N, 3)
    //      idx: (B, N, 3)

    cudaError_t err;
    dim3 blocks(DIVUP(n, THREADS_PER_BLOCK), b);  // blockIdx.x(col), blockIdx.y(row)
    dim3 threads(THREADS_PER_BLOCK);

    three_nn_kernel_fast<<<blocks, threads, 0, stream>>>(b, n, m, unknown, known, dist2, idx);

    err = cudaGetLastError();
    if (cudaSuccess != err) {
        fprintf(stderr, "CUDA kernel failed : %s\n", cudaGetErrorString(err));
        exit(-1);
    }
}


__global__ void three_interpolate_kernel_fast(int b, int c, int m, int n, const float *__restrict__ points, 
    const int *__restrict__ idx, const float *__restrict__ weight, float *__restrict__ out) {
    // points: (B, C, M)
    // idx: (B, N, 3)
    // weight: (B, N, 3)
    // output:
    //      out: (B, C, N)

    int bs_idx = blockIdx.z;
    int c_idx = blockIdx.y;
    int pt_idx = blockIdx.x * blockDim.x + threadIdx.x;

    if (bs_idx >= b || c_idx >= c || pt_idx >= n) return;

    weight += bs_idx * n * 3 + pt_idx * 3;
    points += bs_idx * c * m + c_idx * m;
    idx += bs_idx * n * 3 + pt_idx * 3;
    out += bs_idx * c * n + c_idx * n;

    out[pt_idx] = weight[0] * points[idx[0]] + weight[1] * points[idx[1]] + weight[2] * points[idx[2]];
}

void three_interpolate_kernel_launcher_fast(int b, int c, int m, int n, 
    const float *points, const int *idx, const float *weight, float *out, cudaStream_t stream) {
    // points: (B, C, M)
    // idx: (B, N, 3)
    // weight: (B, N, 3)
    // output:
    //      out: (B, C, N)

    cudaError_t err;
    dim3 blocks(DIVUP(n, THREADS_PER_BLOCK), c, b);  // blockIdx.x(col), blockIdx.y(row)
    dim3 threads(THREADS_PER_BLOCK);
    three_interpolate_kernel_fast<<<blocks, threads, 0, stream>>>(b, c, m, n, points, idx, weight, out);

    err = cudaGetLastError();
    if (cudaSuccess != err) {
        fprintf(stderr, "CUDA kernel failed : %s\n", cudaGetErrorString(err));
        exit(-1);
    }
}


__global__ void three_interpolate_grad_kernel_fast(int b, int c, int n, int m, const float *__restrict__ grad_out, 
    const int *__restrict__ idx, const float *__restrict__ weight, float *__restrict__ grad_points) {
    // grad_out: (B, C, N)
    // weight: (B, N, 3)
    // output:
    //      grad_points: (B, C, M)

    int bs_idx = blockIdx.z;
    int c_idx = blockIdx.y;
    int pt_idx = blockIdx.x * blockDim.x + threadIdx.x;

    if (bs_idx >= b || c_idx >= c || pt_idx >= n) return;
    
    grad_out += bs_idx * c * n + c_idx * n + pt_idx;
    weight += bs_idx * n * 3 + pt_idx * 3;
    grad_points += bs_idx * c * m + c_idx * m;
    idx += bs_idx * n * 3 + pt_idx * 3;


    atomicAdd(grad_points + idx[0], grad_out[0] * weight[0]);
    atomicAdd(grad_points + idx[1], grad_out[0] * weight[1]);
    atomicAdd(grad_points + idx[2], grad_out[0] * weight[2]);
}

void three_interpolate_grad_kernel_launcher_fast(int b, int c, int n, int m, const float *grad_out, 
    const int *idx, const float *weight, float *grad_points, cudaStream_t stream) {
    // grad_out: (B, C, N)
    // weight: (B, N, 3)
    // output:
    //      grad_points: (B, C, M)

    cudaError_t err;
    dim3 blocks(DIVUP(n, THREADS_PER_BLOCK), c, b);  // blockIdx.x(col), blockIdx.y(row)
    dim3 threads(THREADS_PER_BLOCK);
    three_interpolate_grad_kernel_fast<<<blocks, threads, 0, stream>>>(b, c, n, m, grad_out, idx, weight, grad_points);

    err = cudaGetLastError();
    if (cudaSuccess != err) {
        fprintf(stderr, "CUDA kernel failed : %s\n", cudaGetErrorString(err));
        exit(-1);
    }
}

================================================
FILE: pointnet2/src/interpolate_gpu.h
================================================
#ifndef _INTERPOLATE_GPU_H
#define _INTERPOLATE_GPU_H

#include <torch/serialize/tensor.h>
#include<vector>
#include <cuda.h>
#include <cuda_runtime_api.h>


void three_nn_wrapper_fast(int b, int n, int m, at::Tensor unknown_tensor, 
  at::Tensor known_tensor, at::Tensor dist2_tensor, at::Tensor idx_tensor);

void three_nn_kernel_launcher_fast(int b, int n, int m, const float *unknown,
	const float *known, float *dist2, int *idx, cudaStream_t stream);


void three_interpolate_wrapper_fast(int b, int c, int m, int n, at::Tensor points_tensor, 
    at::Tensor idx_tensor, at::Tensor weight_tensor, at::Tensor out_tensor);

void three_interpolate_kernel_launcher_fast(int b, int c, int m, int n, 
    const float *points, const int *idx, const float *weight, float *out, cudaStream_t stream);


void three_interpolate_grad_wrapper_fast(int b, int c, int n, int m, at::Tensor grad_out_tensor, 
    at::Tensor idx_tensor, at::Tensor weight_tensor, at::Tensor grad_points_tensor);

void three_interpolate_grad_kernel_launcher_fast(int b, int c, int n, int m, const float *grad_out, 
    const int *idx, const float *weight, float *grad_points, cudaStream_t stream);

#endif


================================================
FILE: pointnet2/src/pointnet2_api.cpp
================================================
#include <torch/serialize/tensor.h>
#include <torch/extension.h>

#include "ball_query_gpu.h"
#include "group_points_gpu.h"
#include "sampling_gpu.h"
#include "interpolate_gpu.h"


PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
    m.def("ball_query_wrapper", &ball_query_wrapper_fast, "ball_query_wrapper_fast");

    m.def("group_points_wrapper", &group_points_wrapper_fast, "group_points_wrapper_fast");
    m.def("group_points_grad_wrapper", &group_points_grad_wrapper_fast, "group_points_grad_wrapper_fast");

    m.def("gather_points_wrapper", &gather_points_wrapper_fast, "gather_points_wrapper_fast");
    m.def("gather_points_grad_wrapper", &gather_points_grad_wrapper_fast, "gather_points_grad_wrapper_fast");

    m.def("furthest_point_sampling_wrapper", &furthest_point_sampling_wrapper, "furthest_point_sampling_wrapper");
    
    m.def("three_nn_wrapper", &three_nn_wrapper_fast, "three_nn_wrapper_fast");
    m.def("three_interpolate_wrapper", &three_interpolate_wrapper_fast, "three_interpolate_wrapper_fast");
    m.def("three_interpolate_grad_wrapper", &three_interpolate_grad_wrapper_fast, "three_interpolate_grad_wrapper_fast");
}


================================================
FILE: pointnet2/src/sampling.cpp
================================================
#include <torch/serialize/tensor.h>
#include <ATen/cuda/CUDAContext.h>
#include <vector>
#include <THC/THC.h>

#include "sampling_gpu.h"

extern THCState *state;


int gather_points_wrapper_fast(int b, int c, int n, int npoints, 
    at::Tensor points_tensor, at::Tensor idx_tensor, at::Tensor out_tensor){
    const float *points = points_tensor.data<float>();
    const int *idx = idx_tensor.data<int>();
    float *out = out_tensor.data<float>();

    cudaStream_t stream = THCState_getCurrentStream(state);
    gather_points_kernel_launcher_fast(b, c, n, npoints, points, idx, out, stream);
    return 1;
}


int gather_points_grad_wrapper_fast(int b, int c, int n, int npoints, 
    at::Tensor grad_out_tensor, at::Tensor idx_tensor, at::Tensor grad_points_tensor) {

    const float *grad_out = grad_out_tensor.data<float>();
    const int *idx = idx_tensor.data<int>();
    float *grad_points = grad_points_tensor.data<float>();

    cudaStream_t stream = THCState_getCurrentStream(state);
    gather_points_grad_kernel_launcher_fast(b, c, n, npoints, grad_out, idx, grad_points, stream);
    return 1;
}


int furthest_point_sampling_wrapper(int b, int n, int m, 
    at::Tensor points_tensor, at::Tensor temp_tensor, at::Tensor idx_tensor) {

    const float *points = points_tensor.data<float>();
    float *temp = temp_tensor.data<float>();
    int *idx = idx_tensor.data<int>();

    cudaStream_t stream = THCState_getCurrentStream(state);
    furthest_point_sampling_kernel_launcher(b, n, m, points, temp, idx, stream);
    return 1;
}


================================================
FILE: pointnet2/src/sampling_gpu.cu
================================================
#include <stdio.h>
#include <stdlib.h>

#include "cuda_utils.h"
#include "sampling_gpu.h"


__global__ void gather_points_kernel_fast(int b, int c, int n, int m, 
    const float *__restrict__ points, const int *__restrict__ idx, float *__restrict__ out) {
    // points: (B, C, N)
    // idx: (B, M)
    // output:
    //      out: (B, C, M)

    int bs_idx = blockIdx.z;
    int c_idx = blockIdx.y;
    int pt_idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (bs_idx >= b || c_idx >= c || pt_idx >= m) return;

    out += bs_idx * c * m + c_idx * m + pt_idx;
    idx += bs_idx * m + pt_idx;
    points += bs_idx * c * n + c_idx * n;
    out[0] = points[idx[0]];
}

void gather_points_kernel_launcher_fast(int b, int c, int n, int npoints, 
    const float *points, const int *idx, float *out, cudaStream_t stream) {
    // points: (B, C, N)
    // idx: (B, npoints)
    // output:
    //      out: (B, C, npoints)

    cudaError_t err;
    dim3 blocks(DIVUP(npoints, THREADS_PER_BLOCK), c, b);  // blockIdx.x(col), blockIdx.y(row)
    dim3 threads(THREADS_PER_BLOCK);

    gather_points_kernel_fast<<<blocks, threads, 0, stream>>>(b, c, n, npoints, points, idx, out);

    err = cudaGetLastError();
    if (cudaSuccess != err) {
        fprintf(stderr, "CUDA kernel failed : %s\n", cudaGetErrorString(err));
        exit(-1);
    }
}

__global__ void gather_points_grad_kernel_fast(int b, int c, int n, int m, const float *__restrict__ grad_out, 
    const int *__restrict__ idx, float *__restrict__ grad_points) {
    // grad_out: (B, C, M)
    // idx: (B, M)
    // output:
    //      grad_points: (B, C, N)

    int bs_idx = blockIdx.z;
    int c_idx = blockIdx.y;
    int pt_idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (bs_idx >= b || c_idx >= c || pt_idx >= m) return;

    grad_out += bs_idx * c * m + c_idx * m + pt_idx;
    idx += bs_idx * m + pt_idx;
    grad_points += bs_idx * c * n + c_idx * n;

    atomicAdd(grad_points + idx[0], grad_out[0]);
}

void gather_points_grad_kernel_launcher_fast(int b, int c, int n, int npoints, 
    const float *grad_out, const int *idx, float *grad_points, cudaStream_t stream) {
    // grad_out: (B, C, npoints)
    // idx: (B, npoints)
    // output:
    //      grad_points: (B, C, N)

    cudaError_t err;
    dim3 blocks(DIVUP(npoints, THREADS_PER_BLOCK), c, b);  // blockIdx.x(col), blockIdx.y(row)
    dim3 threads(THREADS_PER_BLOCK);

    gather_points_grad_kernel_fast<<<blocks, threads, 0, stream>>>(b, c, n, npoints, grad_out, idx, grad_points);

    err = cudaGetLastError();
    if (cudaSuccess != err) {
        fprintf(stderr, "CUDA kernel failed : %s\n", cudaGetErrorString(err));
        exit(-1);
    }
}


__device__ void __update(float *__restrict__ dists, int *__restrict__ dists_i, int idx1, int idx2){
    const float v1 = dists[idx1], v2 = dists[idx2];
    const int i1 = dists_i[idx1], i2 = dists_i[idx2];
    dists[idx1] = max(v1, v2);
    dists_i[idx1] = v2 > v1 ? i2 : i1;
}

template <unsigned int block_size>
__global__ void furthest_point_sampling_kernel(int b, int n, int m, 
    const float *__restrict__ dataset, float *__restrict__ temp, int *__restrict__ idxs) {
    // dataset: (B, N, 3)
    // tmp: (B, N)
    // output:
    //      idx: (B, M)

    if (m <= 0) return;
    __shared__ float dists[block_size];
    __shared__ int dists_i[block_size];

    int batch_index = blockIdx.x;
    dataset += batch_index * n * 3;
    temp += batch_index * n;
    idxs += batch_index * m;

    int tid = threadIdx.x;
    const int stride = block_size;

    int old = 0;
    if (threadIdx.x == 0)
    idxs[0] = old;

    __syncthreads();
    for (int j = 1; j < m; j++) {
    int besti = 0;
    float best = -1;
    float x1 = dataset[old * 3 + 0];
    float y1 = dataset[old * 3 + 1];
    float z1 = dataset[old * 3 + 2];
    for (int k = tid; k < n; k += stride) {
        float x2, y2, z2;
        x2 = dataset[k * 3 + 0];
        y2 = dataset[k * 3 + 1];
        z2 = dataset[k * 3 + 2];
        // float mag = (x2 * x2) + (y2 * y2) + (z2 * z2);
        // if (mag <= 1e-3)
        // continue;

        float d = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1) + (z2 - z1) * (z2 - z1);
        float d2 = min(d, temp[k]);
        temp[k] = d2;
        besti = d2 > best ? k : besti;
        best = d2 > best ? d2 : best;
    }
    dists[tid] = best;
    dists_i[tid] = besti;
    __syncthreads();

    if (block_size >= 1024) {
        if (tid < 512) {
            __update(dists, dists_i, tid, tid + 512);
        }
        __syncthreads();
    }

    if (block_size >= 512) {
        if (tid < 256) {
            __update(dists, dists_i, tid, tid + 256);
        }
        __syncthreads();
    }
    if (block_size >= 256) {
        if (tid < 128) {
            __update(dists, dists_i, tid, tid + 128);
        }
        __syncthreads();
    }
    if (block_size >= 128) {
        if (tid < 64) {
            __update(dists, dists_i, tid, tid + 64);
        }
        __syncthreads();
    }
    if (block_size >= 64) {
        if (tid < 32) {
            __update(dists, dists_i, tid, tid + 32);
        }
        __syncthreads();
    }
    if (block_size >= 32) {
        if (tid < 16) {
            __update(dists, dists_i, tid, tid + 16);
        }
        __syncthreads();
    }
    if (block_size >= 16) {
        if (tid < 8) {
            __update(dists, dists_i, tid, tid + 8);
        }
        __syncthreads();
    }
    if (block_size >= 8) {
        if (tid < 4) {
            __update(dists, dists_i, tid, tid + 4);
        }
        __syncthreads();
    }
    if (block_size >= 4) {
        if (tid < 2) {
            __update(dists, dists_i, tid, tid + 2);
        }
        __syncthreads();
    }
    if (block_size >= 2) {
        if (tid < 1) {
            __update(dists, dists_i, tid, tid + 1);
        }
        __syncthreads();
    }

    old = dists_i[0];
    if (tid == 0)
        idxs[j] = old;
    }
}

void furthest_point_sampling_kernel_launcher(int b, int n, int m, 
    const float *dataset, float *temp, int *idxs, cudaStream_t stream) {
    // dataset: (B, N, 3)
    // tmp: (B, N)
    // output:
    //      idx: (B, M)

    cudaError_t err;
    unsigned int n_threads = opt_n_threads(n);

    switch (n_threads) {
        case 1024:
        furthest_point_sampling_kernel<1024><<<b, n_threads, 0, stream>>>(b, n, m, dataset, temp, idxs); break;
        case 512:
        furthest_point_sampling_kernel<512><<<b, n_threads, 0, stream>>>(b, n, m, dataset, temp, idxs); break;
        case 256:
        furthest_point_sampling_kernel<256><<<b, n_threads, 0, stream>>>(b, n, m, dataset, temp, idxs); break;
        case 128:
        furthest_point_sampling_kernel<128><<<b, n_threads, 0, stream>>>(b, n, m, dataset, temp, idxs); break;
        case 64:
        furthest_point_sampling_kernel<64><<<b, n_threads, 0, stream>>>(b, n, m, dataset, temp, idxs); break;
        case 32:
        furthest_point_sampling_kernel<32><<<b, n_threads, 0, stream>>>(b, n, m, dataset, temp, idxs); break;
        case 16:
        furthest_point_sampling_kernel<16><<<b, n_threads, 0, stream>>>(b, n, m, dataset, temp, idxs); break;
        case 8:
        furthest_point_sampling_kernel<8><<<b, n_threads, 0, stream>>>(b, n, m, dataset, temp, idxs); break;
        case 4:
        furthest_point_sampling_kernel<4><<<b, n_threads, 0, stream>>>(b, n, m, dataset, temp, idxs); break;
        case 2:
        furthest_point_sampling_kernel<2><<<b, n_threads, 0, stream>>>(b, n, m, dataset, temp, idxs); break;
        case 1:
        furthest_point_sampling_kernel<1><<<b, n_threads, 0, stream>>>(b, n, m, dataset, temp, idxs); break;
        default:
        furthest_point_sampling_kernel<512><<<b, n_threads, 0, stream>>>(b, n, m, dataset, temp, idxs);
    }

    err = cudaGetLastError();
    if (cudaSuccess != err) {
        fprintf(stderr, "CUDA kernel failed : %s\n", cudaGetErrorString(err));
        exit(-1);
    }
}


================================================
FILE: pointnet2/src/sampling_gpu.h
================================================
#ifndef _SAMPLING_GPU_H
#define _SAMPLING_GPU_H

#include <torch/serialize/tensor.h>
#include <ATen/cuda/CUDAContext.h>
#include<vector>


int gather_points_wrapper_fast(int b, int c, int n, int npoints, 
    at::Tensor points_tensor, at::Tensor idx_tensor, at::Tensor out_tensor);

void gather_points_kernel_launcher_fast(int b, int c, int n, int npoints, 
    const float *points, const int *idx, float *out, cudaStream_t stream);


int gather_points_grad_wrapper_fast(int b, int c, int n, int npoints, 
    at::Tensor grad_out_tensor, at::Tensor idx_tensor, at::Tensor grad_points_tensor);

void gather_points_grad_kernel_launcher_fast(int b, int c, int n, int npoints, 
    const float *grad_out, const int *idx, float *grad_points, cudaStream_t stream);


int furthest_point_sampling_wrapper(int b, int n, int m, 
    at::Tensor points_tensor, at::Tensor temp_tensor, at::Tensor idx_tensor);

void furthest_point_sampling_kernel_launcher(int b, int n, int m, 
    const float *dataset, float *temp, int *idxs, cudaStream_t stream);

#endif


================================================
FILE: tools/_init_path.py
================================================
import os, sys
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), '../'))


================================================
FILE: tools/data/KITTI/ImageSets/test.txt
================================================
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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

================================================
FILE: tools/data/KITTI/ImageSets/train.txt
================================================
000000
000003
000007
000009
000010
000011
000012
000013
000014
000016
000017
000018
000022
000026
000029
000030
000032
000034
000036
000038
000041
000043
000044
000045
000046
000049
000051
000054
000055
000056
000057
000060
000064
000067
000068
000069
000070
000071
000072
000073
000074
000075
000079
000080
000082
000083
000084
000085
000086
000087
000088
000091
000092
000095
000096
000097
000099
000100
000101
000103
000105
000109
000110
000111
000112
000113
000114
000115
000119
000120
000121
000123
000125
000127
000129
000130
000131
000133
000136
000138
000141
000142
000144
000145
000146
000148
000149
000150
000154
000155
000157
000158
000160
000162
000163
000164
000165
000166
000171
000172
000176
000177
000178
000179
000180
000184
000185
000189
000193
000198
000200
000202
000205
000206
000208
000209
000210
000214
000215
000217
000219
000220
000221
000222
000225
000227
000228
000232
000233
000238
000240
000241
000243
000244
000245
000253
000254
000255
000256
000257
000258
000259
000261
000264
000267
000271
000274
000275
000276
000277
000280
000282
000285
000286
000287
000288
000292
000294
000295
000296
000298
000299
000300
000303
000304
000306
000310
000313
000316
000317
000318
000322
000325
000326
000330
000331
000334
000337
000338
000339
000342
000344
000348
000349
000353
000358
000363
000364
000367
000368
000371
000374
000375
000380
000384
000387
000389
000390
000400
000405
000406
000410
000411
000412
000416
000417
000418
000421
000423
000424
000425
000426
000431
000432
000433
000434
000435
000438
000439
000441
000442
000444
000445
000447
000449
000456
000458
000460
000461
000462
000464
000465
000466
000467
000470
000471
000474
000482
000483
000484
000487
000488
000490
000497
000500
000501
000502
000505
000507
000511
000513
000514
000516
000518
000520
000522
000523
000525
000526
000529
000531
000532
000534
000535
000537
000538
000539
000540
000544
000547
000549
000550
000552
000553
000556
000557
000562
000563
000565
000570
000573
000574
000575
000576
000577
000578
000579
000580
000582
000584
000585
000586
000587
000592
000593
000594
000596
000597
000598
000599
000602
000603
000605
000606
000607
000608
000609
000616
000617
000621
000622
000623
000627
000629
000631
000632
000633
000637
000638
000640
000641
000643
000646
000649
000651
000652
000653
000654
000656
000661
000662
000663
000664
000665
000666
000668
000671
000672
000673
000675
000676
000678
000680
000681
000685
000686
000687
000688
000689
000690
000693
000695
000697
000701
000703
000705
000707
000709
000710
000711
000712
000713
000714
000715
000719
000720
000723
000724
000726
000730
000732
000733
000735
000738
000739
000742
000743
000744
000747
000749
000753
000755
000757
000758
000759
000760
000762
000763
000764
000770
000775
000776
000777
000780
000781
000783
000784
000785
000786
000787
000788
000789
000791
000793
000794
000796
000797
000799
000808
000813
000814
000815
000817
000818
000820
000821
000822
000824
000825
000827
000828
000829
000830
000832
000833
000834
000835
000836
000839
000842
000845
000846
000851
000853
000855
000856
000857
000858
000860
000861
000864
000865
000866
000867
000868
000870
000871
000872
000880
000882
000883
000886
000887
000888
000890
000891
000892
000895
000896
000898
000900
000901
000902
000903
000905
000906
000908
000910
000913
000914
000918
000919
000921
000924
000925
000927
000929
000933
000934
000935
000936
000937
000941
000945
000946
000947
000950
000951
000954
000955
000957
000959
000960
000962
000965
000968
000972
000975
000977
000978
000980
000982
000987
000989
000990
000992
000993
000994
000995
000996
000997
000998
001000
001001
001003
001004
001005
001009
001016
001017
001020
001023
001024
001028
001029
001030
001031
001032
001033
001034
001036
001038
001040
001041
001044
001045
001047
001048
001049
001052
001056
001057
001059
001060
001061
001062
001064
001072
001073
001074
001079
001080
001081
001082
001085
001087
001090
001091
001092
001093
001098
001100
001103
001105
001109
001110
001112
001117
001119
001121
001122
001124
001126
001128
001130
001137
001142
001146
001151
001156
001157
001159
001160
001161
001164
001165
001166
001168
001169
001170
001171
001174
001175
001181
001184
001185
001186
001190
001196
001197
001200
001201
001202
001204
001205
001208
001209
001210
001211
001212
001215
001219
001220
001223
001227
001229
001231
001233
001238
001240
001247
001248
001250
001256
001258
001262
001264
001276
001277
001278
001279
001280
001282
001283
001285
001288
001290
001293
001297
001298
001299
001300
001301
001302
001309
001310
001311
001312
001313
001315
001316
001319
001320
001321
001322
001323
001324
001325
001326
001327
001328
001335
001338
001340
001341
001343
001348
001349
001351
001354
001357
001358
001360
001361
001362
001364
001366
001367
001368
001369
001370
001371
001373
001378
001379
001383
001385
001390
001392
001393
001394
001396
001399
001400
001401
001402
001403
001404
001405
001406
001408
001409
001413
001414
001417
001418
001420
001422
001423
001425
001426
001428
001429
001430
001433
001434
001436
001440
001444
001447
001449
001452
001453
001454
001455
001456
001457
001459
001460
001462
001464
001465
001467
001468
001470
001472
001473
001474
001475
001476
001479
001482
001483
001484
001486
001490
001491
001492
001493
001494
001496
001498
001499
001500
001503
001504
001505
001506
001509
001510
001512
001515
001518
001519
001520
001523
001529
001530
001531
001532
001534
001539
001540
001541
001543
001544
001548
001550
001551
001553
001554
001556
001558
001559
001561
001563
001566
001568
001570
001571
001572
001575
001578
001580
001581
001584
001593
001595
001598
001599
001601
001604
001607
001608
001609
001611
001612
001614
001618
001620
001622
001623
001624
001626
001628
001630
001632
001636
001637
001638
001639
001641
001642
001644
001646
001648
001649
001651
001652
001653
001655
001657
001659
001661
001663
001668
001669
001671
001672
001673
001674
001676
001677
001678
001679
001681
001685
001686
001687
001688
001690
001691
001692
001695
001696
001698
001700
001703
001708
001715
001716
001720
001723
001724
001725
001728
001730
001731
001734
001735
001736
001737
001738
001739
001743
001744
001747
001748
001753
001754
001756
001757
001759
001760
001761
001763
001766
001767
001769
001770
001773
001775
001777
001779
001784
001785
001788
001789
001790
001791
001792
001793
001796
001798
001799
001803
001805
001806
001809
001810
001811
001812
001815
001816
001819
001821
001826
001827
001829
001830
001832
001833
001834
001836
001837
001838
001839
001841
001842
001843
001845
001847
001849
001850
001857
001860
001864
001865
001866
001870
001871
001873
001874
001876
001879
001882
001883
001889
001891
001894
001895
001896
001899
001901
001902
001903
001906
001907
001908
001910
001911
001912
001913
001914
001915
001916
001917
001918
001921
001922
001930
001935
001938
001939
001944
001947
001948
001949
001950
001951
001953
001955
001956
001957
001958
001961
001962
001963
001964
001965
001968
001970
001971
001973
001974
001975
001976
001981
001987
001988
001990
001992
001993
001994
001998
002003
002005
002006
002007
002009
002015
002016
002018
002020
002023
002024
002026
002030
002031
002032
002033
002039
002040
002041
002047
002051
002053
002055
002059
002060
002061
002063
002064
002065
002066
002067
002069
002070
002072
002077
002080
002083
002084
002088
002090
002092
002095
002096
002097
002098
002099
002104
002105
002106
002109
002110
002114
002116
002117
002119
002122
002125
002126
002129
002132
002133
002134
002141
002143
002144
002145
002146
002147
002148
002149
002150
002154
002155
002156
002157
002162
002164
002167
002171
002172
002174
002175
002176
002178
002180
002181
002184
002186
002189
002190
002191
002192
002194
002195
002197
002198
002199
002203
002204
002205
002208
002210
002211
002212
002213
002214
002217
002221
002222
002223
002226
002227
002230
002231
002235
002236
002237
002238
002240
002241
002242
002244
002247
002249
002252
002253
002256
002259
002261
002263
002264
002265
002267
002268
002269
002270
002271
002273
002274
002275
002278
002281
002285
002288
002289
002296
002297
002301
002302
002305
002309
002311
002312
002313
002316
002317
002318
002321
002322
002323
002324
002326
002328
002331
002333
002335
002339
002342
002343
002349
002350
002351
002352
002354
002355
002358
002360
002361
002363
002364
002368
002371
002373
002374
002375
002377
002379
002381
002388
002389
002390
002394
002395
002396
002400
002401
002402
002403
002406
002407
002408
002409
002410
002412
002413
002416
002417
002421
002426
002427
002430
002431
002435
002436
002437
002438
002441
002443
002444
002445
002447
002448
002449
002451
002452
002453
002456
002459
002464
002465
002466
002467
002468
002469
002470
002471
002472
002475
002480
002481
002482
002484
002485
002487
002489
002491
002493
002494
002496
002498
002501
002507
002508
002510
002512
002513
002514
002515
002517
002518
002522
002523
002524
002527
002533
002535
002536
002537
002542
002544
002545
002547
002549
002550
002551
002553
002554
002555
002559
002560
002561
002566
002567
002571
002573
002576
002578
002579
002582
002587
002588
002589
002591
002592
002593
002595
002596
002597
002605
002607
002608
002609
002610
002611
002614
002616
002617
002618
002620
002622
002623
002624
002627
002629
002632
002634
002637
002639
002642
002643
002647
002648
002649
002650
002652
002654
002655
002658
002659
002660
002662
002664
002665
002667
002668
002670
002671
002672
002676
002678
002679
002682
002683
002684
002687
002688
002689
002691
002697
002698
002700
002701
002703
002704
002705
002708
002714
002716
002718
002719
002723
002731
002732
002733
002734
002736
002738
002739
002741
002743
002750
002751
002754
002756
002759
002762
002766
002768
002769
002770
002771
002774
002776
002777
002778
002779
002780
002781
002782
002784
002785
002788
002790
002791
002792
002795
002798
002799
002802
002803
002807
002808
002813
002816
002817
002819
002821
002822
002823
002824
002825
002829
002832
002834
002835
002837
002838
002842
002843
002849
002850
002851
002852
002854
002855
002857
002859
002860
002862
002864
002865
002868
002869
002870
002871
002872
002873
002874
002882
002884
002886
002887
002888
002897
002898
002899
002904
002906
002907
002909
002910
002912
002913
002915
002918
002920
002921
002922
002923
002926
002927
002929
002931
002932
002933
002936
002938
002939
002940
002941
002943
002946
002949
002950
002952
002954
002956
002965
002967
002968
002969
002970
002972
002973
002975
002980
002981
002983
002986
002987
002989
002990
002992
002996
002998
003002
003008
003009
003012
003013
003014
003015
003016
003017
003018
003020
003021
003023
003026
003028
003036
003037
003039
003040
003041
003044
003045
003049
003051
003057
003059
003060
003063
003064
003068
003069
003070
003072
003075
003077
003078
003079
003081
003083
003084
003085
003086
003089
003091
003092
003093
003095
003097
003098
003100
003104
003105
003108
003111
003113
003115
003117
003119
003120
003121
003122
003123
003125
003128
003130
003132
003138
003139
003140
003143
003147
003149
003151
003152
003154
003155
003157
003158
003160
003163
003164
003166
003168
003169
003171
003173
003176
003178
003184
003185
003186
003188
003189
003191
003193
003195
003196
003198
003200
003201
003205
003206
003208
003209
003212
003213
003215
003218
003220
003223
003227
003230
003234
003235
003237
003238
003241
003243
003244
003245
003246
003248
003249
003253
003256
003258
003260
003261
003262
003263
003264
003267
003268
003270
003271
003273
003274
003277
003278
003279
003282
003284
003285
003286
003287
003289
003290
003291
003293
003294
003297
003299
003303
003307
003309
003311
003314
003317
003320
003321
003326
003327
003328
003329
003332
003333
003334
003335
003336
003339
003340
003342
003344
003345
003348
003349
003354
003356
003359
003360
003361
003362
003363
003369
003371
003372
003374
003376
003377
003378
003380
003381
003382
003383
003384
003387
003388
003389
003390
003391
003392
003398
003400
003413
003414
003415
003416
003418
003420
003423
003424
003427
003431
003433
003436
003437
003438
003439
003440
003441
003442
003444
003445
003446
003451
003452
003454
003455
003457
003458
003459
003460
003462
003463
003468
003472
003473
003475
003476
003477
003479
003485
003486
003493
003494
003498
003499
003500
003501
003505
003507
003508
003509
003510
003512
003513
003514
003516
003518
003522
003523
003525
003526
003532
003533
003534
003536
003537
003538
003540
003541
003542
003545
003546
003548
003549
003551
003555
003556
003560
003561
003564
003565
003566
003567
003569
003570
003572
003575
003576
003577
003578
003579
003581
003585
003586
003587
003589
003590
003591
003592
003593
003594
003595
003596
003597
003598
003599
003602
003603
003606
003610
003612
003613
003615
003617
003619
003625
003626
003628
003636
003637
003638
003639
003640
003641
003642
003644
003646
003648
003650
003651
003654
003656
003657
003660
003663
003664
003665
003666
003670
003672
003673
003674
003675
003680
003681
003685
003686
003687
003693
003694
003695
003696
003697
003698
003699
003700
003701
003704
003706
003709
003710
003713
003714
003717
003720
003721
003722
003724
003725
003727
003729
003730
003731
003732
003733
003734
003740
003741
003742
003743
003744
003745
003749
003752
003754
003757
003758
003759
003760
003761
003765
003766
003767
003768
003770
003772
003773
003774
003776
003780
003783
003784
003785
003786
003789
003790
003791
003792
003795
003796
003797
003799
003801
003803
003806
003810
003813
003815
003816
003817
003818
003819
003821
003823
003824
003825
003829
003831
003832
003833
003836
003838
003839
003840
003842
003843
003844
003845
003846
003848
003849
003850
003851
003853
003855
003857
003858
003861
003862
003863
003865
003867
003868
003871
003875
003876
003877
003882
003884
003887
003888
003889
003893
003895
003896
003900
003903
003904
003906
003908
003910
003911
003912
003913
003917
003918
003919
003921
003922
003925
003927
003928
003929
003930
003933
003935
003936
003939
003940
003941
003942
003944
003947
003949
003951
003952
003953
003954
003955
003957
003959
003960
003963
003966
003967
003968
003971
003973
003974
003976
003978
003979
003983
003985
003987
003988
003989
003990
003991
003993
003994
003995
003997
003999
004005
004006
004012
004013
004014
004015
004017
004018
004019
004020
004022
004023
004024
004025
004029
004030
004031
004035
004037
004039
004043
004044
004046
004047
004050
004052
004053
004054
004056
004057
004058
004060
004062
004066
004067
004069
004070
004071
004073
004075
004076
004078
004080
004084
004086
004088
004090
004093
004094
004097
004099
004102
004103
004106
004112
004114
004115
004123
004127
004133
004134
004135
004139
004141
004144
004145
004146
004147
004151
004159
004165
004166
004167
004169
004170
004176
004177
004178
004179
004180
004181
004182
004183
004184
004186
004192
004193
004194
004197
004198
004199
004200
004201
004203
004204
004208
004211
004212
004216
004217
004218
004219
004225
004227
004229
004230
004231
004233
004234
004235
004236
004238
004240
004244
004245
004247
004252
004253
004257
004258
004261
004262
004264
004265
004266
004267
004268
004269
004272
004273
004274
004276
004279
004283
004286
004287
004292
004296
004297
004302
004304
004308
004310
004313
004315
004316
004317
004320
004322
004325
004328
004331
004332
004333
004334
004339
004341
004344
004346
004347
004351
004354
004355
004356
004357
004358
004359
004361
004365
004366
004371
004372
004375
004376
004378
004379
004380
004381
004382
004386
004387
004389
004390
004394
004395
004399
004400
004405
004408
004409
004410
004411
004412
004413
004416
004417
004427
004428
004431
004432
004436
004441
004442
004445
004446
004448
004449
004451
004453
004455
004457
004459
004461
004463
004464
004466
004467
004468
004471
004473
004476
004477
004478
004479
004484
004488
004492
004495
004497
004498
004499
004500
004503
004504
004505
004506
004507
004509
004510
004512
004514
004515
004518
004522
004523
004524
004525
004533
004535
004536
004537
004538
004539
004543
004544
004545
004546
004550
004552
004554
004555
004558
004559
004560
004561
004563
004564
004565
004571
004572
004575
004577
004579
004580
004583
004584
004586
004590
004592
004593
004594
004595
004597
004600
004601
004602
004604
004605
004606
004607
004613
004614
004616
004617
004619
004621
004623
004625
004627
004628
004631
004635
004637
004639
004641
004642
004643
004645
004646
004653
004654
004656
004659
004661
004662
004663
004664
004670
004671
004674
004675
004676
004677
004678
004681
004684
004690
004696
004701
004702
004703
004704
004707
004712
004719
004723
004727
004728
004729
004731
004733
004736
004741
004747
004749
004750
004751
004754
004755
004757
004758
004760
004761
004765
004767
004771
004772
004774
004775
004778
004779
004780
004781
004784
004785
004786
004789
004793
004794
004795
004796
004798
004801
004802
004803
004805
004808
004809
004812
004818
004819
004820
004823
004824
004826
004827
004828
004833
004834
004836
004837
004838
004840
004841
004842
004844
004845
004847
004853
004854
004855
004856
004857
004865
004866
004869
004870
004872
004876
004877
004878
004879
004880
004882
004883
004884
004886
004889
004890
004894
004897
004899
004900
004901
004906
004908
004910
004911
004912
004913
004915
004916
004919
004922
004923
004925
004930
004933
004936
004937
004939
004940
004945
004950
004951
004952
004955
004957
004961
004964
004965
004967
004968
004969
004970
004971
004972
004973
004975
004977
004978
004980
004982
004984
004987
004991
004992
004997
005000
005003
005005
005006
005007
005009
005011
005012
005016
005018
005020
005022
005023
005025
005027
005029
005030
005031
005033
005035
005039
005042
005043
005044
005046
005047
005048
005051
005059
005060
005061
005066
005069
005071
005076
005083
005084
005085
005087
005088
005089
005091
005092
005096
005097
005098
005099
005100
005102
005104
005106
005107
005111
005114
005115
005116
005117
005118
005119
005123
005126
005129
005130
005131
005132
005134
005137
005142
005146
005148
005150
005151
005152
005154
005159
005160
005165
005169
005171
005173
005177
005178
005183
005186
005187
005192
005193
005195
005196
005200
005202
005203
005204
005205
005207
005208
005209
005210
005211
005212
005215
005216
005220
005223
005224
005225
005228
005231
005232
005235
005238
005239
005243
005245
005247
005248
005250
005252
005253
005254
005257
005258
005259
005261
005263
005264
005265
005266
005269
005270
005272
005277
005278
005281
005283
005285
005286
005288
005290
005291
005293
005294
005295
005300
005301
005302
005303
005305
005306
005310
005314
005317
005320
005324
005326
005327
005331
005332
005339
005340
005344
005346
005348
005351
005352
005353
005354
005355
005356
005357
005358
005361
005362
005364
005367
005370
005373
005374
005376
005380
005382
005383
005384
005387
005388
005392
005393
005394
005395
005396
005397
005398
005399
005400
005401
005402
005403
005406
005407
005408
005409
005410
005411
005412
005414
005416
005417
005418
005419
005420
005421
005424
005425
005428
005432
005433
005435
005436
005438
005439
005440
005442
005446
005451
005454
005455
005456
005457
005462
005463
005464
005468
005469
005470
005475
005478
005480
005483
005485
005488
005490
005491
005492
005493
005496
005497
005499
005500
005501
005502
005503
005504
005506
005507
005508
005509
005512
005513
005516
005517
005518
005519
005520
005521
005522
005524
005526
005527
005529
005530
005533
005535
005537
005539
005541
005543
005547
005548
005549
005550
005553
005554
005561
005562
005563
005564
005567
005568
005569
005574
005575
005578
005579
005583
005585
005591
005592
005593
005594
005597
005598
005599
005604
005605
005606
005607
005608
005609
005611
005612
005614
005615
005620
005621
005622
005624
005626
005627
005628
005629
005632
005636
005637
005641
005644
005645
005646
005647
005648
005651
005654
005655
005657
005661
005663
005665
005666
005667
005670
005671
005674
005675
005678
005679
005681
005682
005684
005686
005688
005690
005691
005692
005693
005694
005696
005697
005701
005702
005705
005710
005711
005715
005716
005718
005719
005720
005721
005722
005723
005726
005730
005732
005733
005734
005737
005738
005742
005748
005749
005750
005752
005753
005755
005756
005758
005759
005761
005764
005766
005767
005768
005769
005770
005771
005772
005773
005774
005775
005776
005778
005779
005780
005781
005788
005789
005791
005792
005795
005797
005798
005799
005802
005804
005808
005809
005810
005813
005814
005815
005816
005817
005823
005824
005825
005828
005830
005831
005832
005833
005835
005836
005837
005838
005842
005844
005845
005846
005847
005848
005849
005850
005851
005853
005858
005860
005861
005862
005863
005865
005866
005867
005868
005870
005871
005872
005874
005875
005877
005880
005884
005886
005888
005890
005891
005895
005896
005897
005898
005902
005904
005908
005915
005920
005924
005928
005929
005930
005932
005934
005936
005937
005940
005941
005942
005943
005945
005946
005950
005951
005953
005954
005956
005957
005959
005960
005964
005966
005967
005968
005971
005973
005974
005976
005977
005979
005980
005983
005987
005989
005990
005991
005992
005993
005995
005998
006000
006004
006006
006007
006011
006015
006017
006018
006019
006020
006021
006022
006025
006032
006035
006037
006040
006049
006051
006053
006055
006056
006059
006064
006065
006069
006072
006073
006076
006079
006080
006081
006082
006084
006089
006090
006091
006092
006094
006099
006101
006104
006105
006108
006109
006111
006112
006113
006119
006120
006124
006128
006129
006131
006132
006134
006135
006137
006138
006140
006141
006142
006143
006145
006147
006149
006150
006153
006155
006157
006158
006159
006160
006162
006164
006166
006170
006171
006172
006174
006175
006178
006179
006180
006181
006183
006184
006188
006189
006191
006192
006193
006197
006199
006200
006201
006203
006205
006206
006207
006209
006211
006212
006214
006216
006217
006218
006220
006221
006223
006224
006225
006226
006230
006231
006234
006235
006236
006237
006239
006241
006242
006243
006245
006248
006251
006252
006253
006254
006255
006256
006257
006259
006260
006261
006262
006264
006268
006271
006277
006279
006281
006283
006284
006285
006289
006290
006291
006292
006293
006294
006295
006296
006298
006299
006303
006304
006307
006308
006309
006310
006311
006313
006318
006319
006320
006323
006325
006326
006327
006328
006329
006330
006335
006336
006337
006341
006346
006347
006350
006352
006358
006359
006361
006362
006363
006365
006367
006373
006374
006375
006376
006378
006382
006383
006384
006387
006389
006390
006392
006397
006398
006399
006400
006401
006402
006404
006408
006412
006413
006414
006418
006419
006421
006422
006428
006429
006430
006431
006432
006438
006443
006447
006448
006449
006450
006455
006456
006457
006458
006459
006460
006461
006463
006466
006467
006471
006476
006479
006480
006485
006487
006489
006490
006492
006494
006495
006499
006500
006501
006502
006504
006509
006510
006511
006513
006518
006522
006523
006526
006527
006528
006536
006538
006539
006541
006543
006544
006545
006546
006547
006550
006552
006554
006557
006559
006562
006564
006566
006567
006571
006572
006573
006575
006579
006580
006584
006585
006587
006589
006591
006594
006598
006599
006600
006601
006605
006606
006607
006608
006609
006610
006615
006616
006617
006619
006620
006621
006622
006627
006630
006631
006635
006639
006640
006642
006644
006645
006646
006648
006652
006653
006654
006657
006661
006662
006663
006665
006668
006671
006672
006673
006675
006680
006681
006683
006684
006687
006688
006689
006690
006691
006697
006699
006700
006702
006704
006705
006706
006707
006708
006716
006717
006718
006721
006722
006724
006727
006728
006730
006735
006736
006739
006740
006742
006743
006746
006748
006749
006750
006757
006763
006766
006769
006774
006775
006776
006779
006784
006787
006788
006790
006793
006795
006799
006801
006802
006805
006809
006810
006814
006817
006820
006821
006823
006824
006825
006826
006827
006830
006831
006834
006835
006838
006839
006840
006842
006845
006846
006848
006851
006857
006859
006861
006864
006865
006867
006869
006871
006875
006877
006878
006880
006883
006886
006888
006890
006892
006893
006894
006896
006902
006904
006905
006909
006911
006912
006915
006916
006918
006919
006920
006921
006923
006924
006926
006927
006929
006931
006932
006933
006934
006935
006939
006940
006941
006946
006947
006949
006951
006952
006957
006958
006961
006963
006965
006966
006967
006969
006970
006972
006974
006975
006976
006979
006983
006984
006985
006986
006988
006991
006993
006995
006996
006998
007001
007002
007004
007007
007009
007013
007017
007018
007020
007021
007024
007025
007035
007036
007039
007040
007041
007044
007045
007046
007050
007051
007054
007057
007058
007060
007062
007064
007066
007070
007073
007075
007077
007086
007090
007092
007093
007094
007096
007097
007099
007101
007102
007104
007105
007106
007107
007108
007111
007113
007114
007116
007118
007121
007123
007124
007126
007127
007128
007129
007134
007137
007140
007141
007142
007143
007147
007148
007150
007151
007152
007153
007155
007156
007159
007160
007167
007170
007171
007173
007175
007179
007181
007184
007185
007186
007188
007189
007190
007191
007192
007193
007195
007196
007197
007203
007206
007209
007211
007213
007216
007218
007220
007222
007223
007224
007226
007228
007231
007234
007236
007237
007239
007241
007243
007245
007248
007249
007250
007251
007254
007257
007259
007263
007264
007268
007269
007270
007276
007281
007282
007285
007286
007293
007295
007296
007297
007298
007301
007305
007306
007307
007308
007312
007313
007314
007316
007317
007320
007321
007324
007328
007332
007333
007334
007335
007338
007340
007341
007346
007348
007354
007355
007356
007357
007358
007361
007362
007363
007365
007366
007367
007368
007370
007372
007373
007378
007379
007386
007387
007388
007390
007392
007393
007394
007399
007400
007404
007406
007408
007414
007417
007418
007425
007427
007428
007429
007431
007432
007438
007441
007443
007444
007446
007451
007452
007454
007455
007457
007459
007460
007461
007465
007471
007472
007474
007476
007479

================================================
FILE: tools/data/KITTI/ImageSets/trainval.txt
================================================
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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

================================================
FILE: tools/data/KITTI/ImageSets/val.txt
================================================
000001
000002
000004
000005
000006
000008
000015
000019
000020
000021
000023
000024
000025
000027
000028
000031
000033
000035
000037
000039
000040
000042
000047
000048
000050
000052
000053
000058
000059
000061
000062
000063
000065
000066
000076
000077
000078
000081
000089
000090
000093
000094
000098
000102
000104
000106
000107
000108
000116
000117
000118
000122
000124
000126
000128
000132
000134
000135
000137
000139
000140
000143
000147
000151
000152
000153
000156
000159
000161
000167
000168
000169
000170
000173
000174
000175
000181
000182
000183
000186
000187
000188
000190
000191
000192
000194
000195
000196
000197
000199
000201
000203
000204
000207
000211
000212
000213
000216
000218
000223
000224
000226
000229
000230
000231
000234
000235
000236
000237
000239
000242
000246
000247
000248
000249
000250
000251
000252
000260
000262
000263
000265
000266
000268
000269
000270
000272
000273
000278
000279
000281
000283
000284
000289
000290
000291
000293
000297
000301
000302
000305
000307
000308
000309
000311
000312
000314
000315
000319
000320
000321
000323
000324
000327
000328
000329
000332
000333
000335
000336
000340
000341
000343
000345
000346
000347
000350
000351
000352
000354
000355
000356
000357
000359
000360
000361
000362
000365
000366
000369
000370
000372
000373
000376
000377
000378
000379
000381
000382
000383
000385
000386
000388
000391
000392
000393
000394
000395
000396
000397
000398
000399
000401
000402
000403
000404
000407
000408
000409
000413
000414
000415
000419
000420
000422
000427
000428
000429
000430
000436
000437
000440
000443
000446
000448
000450
000451
000452
000453
000454
000455
000457
000459
000463
000468
000469
000472
000473
000475
000476
000477
000478
000479
000480
000481
000485
000486
000489
000491
000492
000493
000494
000495
000496
000498
000499
000503
000504
000506
000508
000509
000510
000512
000515
000517
000519
000521
000524
000527
000528
000530
000533
000536
000541
000542
000543
000545
000546
000548
000551
000554
000555
000558
000559
000560
000561
000564
000566
000567
000568
000569
000571
000572
000581
000583
000588
000589
000590
000591
000595
000600
000601
000604
000610
000611
000612
000613
000614
000615
000618
000619
000620
000624
000625
000626
000628
000630
000634
000635
000636
000639
000642
000644
000645
000647
000648
000650
000655
000657
000658
000659
000660
000667
000669
000670
000674
000677
000679
000682
000683
000684
000691
000692
000694
000696
000698
000699
000700
000702
000704
000706
000708
000716
000717
000718
000721
000722
000725
000727
000728
000729
000731
000734
000736
000737
000740
000741
000745
000746
000748
000750
000751
000752
000754
000756
000761
000765
000766
000767
000768
000769
000771
000772
000773
000774
000778
000779
000782
000790
000792
000795
000798
000800
000801
000802
000803
000804
000805
000806
000807
000809
000810
000811
000812
000816
000819
000823
000826
000831
000837
000838
000840
000841
000843
000844
000847
000848
000849
000850
000852
000854
000859
000862
000863
000869
000873
000874
000875
000876
000877
000878
000879
000881
000884
000885
000889
000893
000894
000897
000899
000904
000907
000909
000911
000912
000915
000916
000917
000920
000922
000923
000926
000928
000930
000931
000932
000938
000939
000940
000942
000943
000944
000948
000949
000952
000953
000956
000958
000961
000963
000964
000966
000967
000969
000970
000971
000973
000974
000976
000979
000981
000983
000984
000985
000986
000988
000991
000999
001002
001006
001007
001008
001010
001011
001012
001013
001014
001015
001018
001019
001021
001022
001025
001026
001027
001035
001037
001039
001042
001043
001046
001050
001051
001053
001054
001055
001058
001063
001065
001066
001067
001068
001069
001070
001071
001075
001076
001077
001078
001083
001084
001086
001088
001089
001094
001095
001096
001097
001099
001101
001102
001104
001106
001107
001108
001111
001113
001114
001115
001116
001118
001120
001123
001125
001127
001129
001131
001132
001133
001134
001135
001136
001138
001139
001140
001141
001143
001144
001145
001147
001148
001149
001150
001152
001153
001154
001155
001158
001162
001163
001167
001172
001173
001176
001177
001178
001179
001180
001182
001183
001187
001188
001189
001191
001192
001193
001194
001195
001198
001199
001203
001206
001207
001213
001214
001216
001217
001218
001221
001222
001224
001225
001226
001228
001230
001232
001234
001235
001236
001237
001239
001241
001242
001243
001244
001245
001246
001249
001251
001252
001253
001254
001255
001257
001259
001260
001261
001263
001265
001266
001267
001268
001269
001270
001271
001272
001273
001274
001275
001281
001284
001286
001287
001289
001291
001292
001294
001295
001296
001303
001304
001305
001306
001307
001308
001314
001317
001318
001329
001330
001331
001332
001333
001334
001336
001337
001339
001342
001344
001345
001346
001347
001350
001352
001353
001355
001356
001359
001363
001365
001372
001374
001375
001376
001377
001380
001381
001382
001384
001386
001387
001388
001389
001391
001395
001397
001398
001407
001410
001411
001412
001415
001416
001419
001421
001424
001427
001431
001432
001435
001437
001438
001439
001441
001442
001443
001445
001446
001448
001450
001451
001458
001461
001463
001466
001469
001471
001477
001478
001480
001481
001485
001487
001488
001489
001495
001497
001501
001502
001507
001508
001511
001513
001514
001516
001517
001521
001522
001524
001525
001526
001527
001528
001533
001535
001536
001537
001538
001542
001545
001546
001547
001549
001552
001555
001557
001560
001562
001564
001565
001567
001569
001573
001574
001576
001577
001579
001582
001583
001585
001586
001587
001588
001589
001590
001591
001592
001594
001596
001597
001600
001602
001603
001605
001606
001610
001613
001615
001616
001617
001619
001621
001625
001627
001629
001631
001633
001634
001635
001640
001643
001645
001647
001650
001654
001656
001658
001660
001662
001664
001665
001666
001667
001670
001675
001680
001682
001683
001684
001689
001693
001694
001697
001699
001701
001702
001704
001705
001706
001707
001709
001710
001711
001712
001713
001714
001717
001718
001719
001721
001722
001726
001727
001729
001732
001733
001740
001741
001742
001745
001746
001749
001750
001751
001752
001755
001758
001762
001764
001765
001768
001771
001772
001774
001776
001778
001780
001781
001782
001783
001786
001787
001794
001795
001797
001800
001801
001802
001804
001807
001808
001813
001814
001817
001818
001820
001822
001823
001824
001825
001828
001831
001835
001840
001844
001846
001848
001851
001852
001853
001854
001855
001856
001858
001859
001861
001862
001863
001867
001868
001869
001872
001875
001877
001878
001880
001881
001884
001885
001886
001887
001888
001890
001892
001893
001897
001898
001900
001904
001905
001909
001919
001920
001923
001924
001925
001926
001927
001928
001929
001931
001932
001933
001934
001936
001937
001940
001941
001942
001943
001945
001946
001952
001954
001959
001960
001966
001967
001969
001972
001977
001978
001979
001980
001982
001983
001984
001985
001986
001989
001991
001995
001996
001997
001999
002000
002001
002002
002004
002008
002010
002011
002012
002013
002014
002017
002019
002021
002022
002025
002027
002028
002029
002034
002035
002036
002037
002038
002042
002043
002044
002045
002046
002048
002049
002050
002052
002054
002056
002057
002058
002062
002068
002071
002073
002074
002075
002076
002078
002079
002081
002082
002085
002086
002087
002089
002091
002093
002094
002100
002101
002102
002103
002107
002108
002111
002112
002113
002115
002118
002120
002121
002123
002124
002127
002128
002130
002131
002135
002136
002137
002138
002139
002140
002142
002151
002152
002153
002158
002159
002160
002161
002163
002165
002166
002168
002169
002170
002173
002177
002179
002182
002183
002185
002187
002188
002193
002196
002200
002201
002202
002206
002207
002209
002215
002216
002218
002219
002220
002224
002225
002228
002229
002232
002233
002234
002239
002243
002245
002246
002248
002250
002251
002254
002255
002257
002258
002260
002262
002266
002272
002276
002277
002279
002280
002282
002283
002284
002286
002287
002290
002291
002292
002293
002294
002295
002298
002299
002300
002303
002304
002306
002307
002308
002310
002314
002315
002319
002320
002325
002327
002329
002330
002332
002334
002336
002337
002338
002340
002341
002344
002345
002346
002347
002348
002353
002356
002357
002359
002362
002365
002366
002367
002369
002370
002372
002376
002378
002380
002382
002383
002384
002385
002386
002387
002391
002392
002393
002397
002398
002399
002404
002405
002411
002414
002415
002418
002419
002420
002422
002423
002424
002425
002428
002429
002432
002433
002434
002439
002440
002442
002446
002450
002454
002455
002457
002458
002460
002461
002462
002463
002473
002474
002476
002477
002478
002479
002483
002486
002488
002490
002492
002495
002497
002499
002500
002502
002503
002504
002505
002506
002509
002511
002516
002519
002520
002521
002525
002526
002528
002529
002530
002531
002532
002534
002538
002539
002540
002541
002543
002546
002548
002552
002556
002557
002558
002562
002563
002564
002565
002568
002569
002570
002572
002574
002575
002577
002580
002581
002583
002584
002585
002586
002590
002594
002598
002599
002600
002601
002602
002603
002604
002606
002612
002613
002615
002619
002621
002625
002626
002628
002630
002631
002633
002635
002636
002638
002640
002641
002644
002645
002646
002651
002653
002656
002657
002661
002663
002666
002669
002673
002674
002675
002677
002680
002681
002685
002686
002690
002692
002693
002694
002695
002696
002699
002702
002706
002707
002709
002710
002711
002712
002713
002715
002717
002720
002721
002722
002724
002725
002726
002727
002728
002729
002730
002735
002737
002740
002742
002744
002745
002746
002747
002748
002749
002752
002753
002755
002757
002758
002760
002761
002763
002764
002765
002767
002772
002773
002775
002783
002786
002787
002789
002793
002794
002796
002797
002800
002801
002804
002805
002806
002809
002810
002811
002812
002814
002815
002818
002820
002826
002827
002828
002830
002831
002833
002836
002839
002840
002841
002844
002845
002846
002847
002848
002853
002856
002858
002861
002863
002866
002867
002875
002876
002877
002878
002879
002880
002881
002883
002885
002889
002890
002891
002892
002893
002894
002895
002896
002900
002901
002902
002903
002905
002908
002911
002914
002916
002917
002919
002924
002925
002928
002930
002934
002935
002937
002942
002944
002945
002947
002948
002951
002953
002955
002957
002958
002959
002960
002961
002962
002963
002964
002966
002971
002974
002976
002977
002978
002979
002982
002984
002985
002988
002991
002993
002994
002995
002997
002999
003000
003001
003003
003004
003005
003006
003007
003010
003011
003019
003022
003024
003025
003027
003029
003030
003031
003032
003033
003034
003035
003038
003042
003043
003046
003047
003048
003050
003052
003053
003054
003055
003056
003058
003061
003062
003065
003066
003067
003071
003073
003074
003076
003080
003082
003087
003088
003090
003094
003096
003099
003101
003102
003103
003106
003107
003109
003110
003112
003114
003116
003118
003124
003126
003127
003129
003131
003133
003134
003135
003136
003137
003141
003142
003144
003145
003146
003148
003150
003153
003156
003159
003161
003162
003165
003167
003170
003172
003174
003175
003177
003179
003180
003181
003182
003183
003187
003190
003192
003194
003197
003199
003202
003203
003204
003207
003210
003211
003214
003216
003217
003219
003221
003222
003224
003225
003226
003228
003229
003231
003232
003233
003236
003239
003240
003242
003247
003250
003251
003252
003254
003255
003257
003259
003265
003266
003269
003272
003275
003276
003280
003281
003283
003288
003292
003295
003296
003298
003300
003301
003302
003304
003305
003306
003308
003310
003312
003313
003315
003316
003318
003319
003322
003323
003324
003325
003330
003331
003337
003338
003341
003343
003346
003347
003350
003351
003352
003353
003355
003357
003358
003364
003365
003366
003367
003368
003370
003373
003375
003379
003385
003386
003393
003394
003395
003396
003397
003399
003401
003402
003403
003404
003405
003406
003407
003408
003409
003410
003411
003412
003417
003419
003421
003422
003425
003426
003428
003429
003430
003432
003434
003435
003443
003447
003448
003449
003450
003453
003456
003461
003464
003465
003466
003467
003469
003470
003471
003474
003478
003480
003481
003482
003483
003484
003487
003488
003489
003490
003491
003492
003495
003496
003497
003502
003503
003504
003506
003511
003515
003517
003519
003520
003521
003524
003527
003528
003529
003530
003531
003535
003539
003543
003544
003547
003550
003552
003553
003554
003557
003558
003559
003562
003563
003568
003571
003573
003574
003580
003582
003583
003584
003588
003600
003601
003604
003605
003607
003608
003609
003611
003614
003616
003618
003620
003621
003622
003623
003624
003627
003629
003630
003631
003632
003633
003634
003635
003643
003645
003647
003649
003652
003653
003655
003658
003659
003661
003662
003667
003668
003669
003671
003676
003677
003678
003679
003682
003683
003684
003688
003689
003690
003691
003692
003702
003703
003705
003707
003708
003711
003712
003715
003716
003718
003719
003723
003726
003728
003735
003736
003737
003738
003739
003746
003747
003748
003750
003751
003753
003755
003756
003762
003763
003764
003769
003771
003775
003777
003778
003779
003781
003782
003787
003788
003793
003794
003798
003800
003802
003804
003805
003807
003808
003809
003811
003812
003814
003820
003822
003826
003827
003828
003830
003834
003835
003837
003841
003847
003852
003854
003856
003859
003860
003864
003866
003869
003870
003872
003873
003874
003878
003879
003880
003881
003883
003885
003886
003890
003891
003892
003894
003897
003898
003899
003901
003902
003905
003907
003909
003914
003915
003916
003920
003923
003924
003926
003931
003932
003934
003937
003938
003943
003945
003946
003948
003950
003956
003958
003961
003962
003964
003965
003969
003970
003972
003975
003977
003980
003981
003982
003984
003986
003992
003996
003998
004000
004001
004002
004003
004004
004007
004008
004009
004010
004011
004016
004021
004026
004027
004028
004032
004033
004034
004036
004038
004040
004041
004042
004045
004048
004049
004051
004055
004059
004061
004063
004064
004065
004068
004072
004074
004077
004079
004081
004082
004083
004085
004087
004089
004091
004092
004095
004096
004098
004100
004101
004104
004105
004107
004108
004109
004110
004111
004113
004116
004117
004118
004119
004120
004121
004122
004124
004125
004126
004128
004129
004130
004131
004132
004136
004137
004138
004140
004142
004143
004148
004149
004150
004152
004153
004154
004155
004156
004157
004158
004160
004161
004162
004163
004164
004168
004171
004172
004173
004174
004175
004185
004187
004188
004189
004190
004191
004195
004196
004202
004205
004206
004207
004209
004210
004213
004214
004215
004220
004221
004222
004223
004224
004226
004228
004232
004237
004239
004241
004242
004243
004246
004248
004249
004250
004251
004254
004255
004256
004259
004260
004263
004270
004271
004275
004277
004278
004280
004281
004282
004284
004285
004288
004289
004290
004291
004293
004294
004295
004298
004299
004300
004301
004303
004305
004306
004307
004309
004311
004312
004314
004318
004319
004321
004323
004324
004326
004327
004329
004330
004335
004336
004337
004338
004340
004342
004343
004345
004348
004349
004350
004352
004353
004360
004362
004363
004364
004367
004368
004369
004370
004373
004374
004377
004383
004384
004385
004388
004391
004392
004393
004396
004397
004398
004401
004402
004403
004404
004406
004407
004414
004415
004418
004419
004420
004421
004422
004423
004424
004425
004426
004429
004430
004433
004434
004435
004437
004438
004439
004440
004443
004444
004447
004450
004452
004454
004456
004458
004460
004462
004465
004469
004470
004472
004474
004475
004480
004481
004482
004483
004485
004486
004487
004489
004490
004491
004493
004494
004496
004501
004502
004508
004511
004513
004516
004517
004519
004520
004521
004526
004527
004528
004529
004530
004531
004532
004534
004540
004541
004542
004547
004548
004549
004551
004553
004556
004557
004562
004566
004567
004568
004569
004570
004573
004574
004576
004578
004581
004582
004585
004587
004588
004589
004591
004596
004598
004599
004603
004608
004609
004610
004611
004612
004615
004618
004620
004622
004624
004626
004629
004630
004632
004633
004634
004636
004638
004640
004644
004647
004648
004649
004650
004651
004652
004655
004657
004658
004660
004665
004666
004667
004668
004669
004672
004673
004679
004680
004682
004683
004685
004686
004687
004688
004689
004691
004692
004693
004694
004695
004697
004698
004699
004700
004705
004706
004708
004709
004710
004711
004713
004714
004715
004716
004717
004718
004720
004721
004722
004724
004725
004726
004730
004732
004734
004735
004737
004738
004739
004740
004742
004743
004744
004745
004746
004748
004752
004753
004756
004759
004762
004763
004764
004766
004768
004769
004770
004773
004776
004777
004782
004783
004787
004788
004790
004791
004792
004797
004799
004800
004804
004806
004807
004810
004811
004813
004814
004815
004816
004817
004821
004822
004825
004829
004830
004831
004832
004835
004839
004843
004846
004848
004849
004850
004851
004852
004858
004859
004860
004861
004862
004863
004864
004867
004868
004871
004873
004874
004875
004881
004885
004887
004888
004891
004892
004893
004895
004896
004898
004902
004903
004904
004905
004907
004909
004914
004917
004918
004920
004921
004924
004926
004927
004928
004929
004931
004932
004934
004935
004938
004941
004942
004943
004944
004946
004947
004948
004949
004953
004954
004956
004958
004959
004960
004962
004963
004966
004974
004976
004979
004981
004983
004985
004986
004988
004989
004990
004993
004994
004995
004996
004998
004999
005001
005002
005004
005008
005010
005013
005014
005015
005017
005019
005021
005024
005026
005028
005032
005034
005036
005037
005038
005040
005041
005045
005049
005050
005052
005053
005054
005055
005056
005057
005058
005062
005063
005064
005065
005067
005068
005070
005072
005073
005074
005075
005077
005078
005079
005080
005081
005082
005086
005090
005093
005094
005095
005101
005103
005105
005108
005109
005110
005112
005113
005120
005121
005122
005124
005125
005127
005128
005133
005135
005136
005138
005139
005140
005141
005143
005144
005145
005147
005149
005153
005155
005156
005157
005158
005161
005162
005163
005164
005166
005167
005168
005170
005172
005174
005175
005176
005179
005180
005181
005182
005184
005185
005188
005189
005190
005191
005194
005197
005198
005199
005201
005206
005213
005214
005217
005218
005219
005221
005222
005226
005227
005229
005230
005233
005234
005236
005237
005240
005241
005242
005244
005246
005249
005251
005255
005256
005260
005262
005267
005268
005271
005273
005274
005275
005276
005279
005280
005282
005284
005287
005289
005292
005296
005297
005298
005299
005304
005307
005308
005309
005311
005312
005313
005315
005316
005318
005319
005321
005322
005323
005325
005328
005329
005330
005333
005334
005335
005336
005337
005338
005341
005342
005343
005345
005347
005349
005350
005359
005360
005363
005365
005366
005368
005369
005371
005372
005375
005377
005378
005379
005381
005385
005386
005389
005390
005391
005404
005405
005413
005415
005422
005423
005426
005427
005429
005430
005431
005434
005437
005441
005443
005444
005445
005447
005448
005449
005450
005452
005453
005458
005459
005460
005461
005465
005466
005467
005471
005472
005473
005474
005476
005477
005479
005481
005482
005484
005486
005487
005489
005494
005495
005498
005505
005510
005511
005514
005515
005523
005525
005528
005531
005532
005534
005536
005538
005540
005542
005544
005545
005546
005551
005552
005555
005556
005557
005558
005559
005560
005565
005566
005570
005571
005572
005573
005576
005577
005580
005581
005582
005584
005586
005587
005588
005589
005590
005595
005596
005600
005601
005602
005603
005610
005613
005616
005617
005618
005619
005623
005625
005630
005631
005633
005634
005635
005638
005639
005640
005642
005643
005649
005650
005652
005653
005656
005658
005659
005660
005662
005664
005668
005669
005672
005673
005676
005677
005680
005683
005685
005687
005689
005695
005698
005699
005700
005703
005704
005706
005707
005708
005709
005712
005713
005714
005717
005724
005725
005727
005728
005729
005731
005735
005736
005739
005740
005741
005743
005744
005745
005746
005747
005751
005754
005757
005760
005762
005763
005765
005777
005782
005783
005784
005785
005786
005787
005790
005793
005794
005796
005800
005801
005803
005805
005806
005807
005811
005812
005818
005819
005820
005821
005822
005826
005827
005829
005834
005839
005840
005841
005843
005852
005854
005855
005856
005857
005859
005864
005869
005873
005876
005878
005879
005881
005882
005883
005885
005887
005889
005892
005893
005894
005899
005900
005901
005903
005905
005906
005907
005909
005910
005911
005912
005913
005914
005916
005917
005918
005919
005921
005922
005923
005925
005926
005927
005931
005933
005935
005938
005939
005944
005947
005948
005949
005952
005955
005958
005961
005962
005963
005965
005969
005970
005972
005975
005978
005981
005982
005984
005985
005986
005988
005994
005996
005997
005999
006001
006002
006003
006005
006008
006009
006010
006012
006013
006014
006016
006023
006024
006026
006027
006028
006029
006030
006031
006033
006034
006036
006038
006039
006041
006042
006043
006044
006045
006046
006047
006048
006050
006052
006054
006057
006058
006060
006061
006062
006063
006066
006067
006068
006070
006071
006074
006075
006077
006078
006083
006085
006086
006087
006088
006093
006095
006096
006097
006098
006100
006102
006103
006106
006107
006110
006114
006115
006116
006117
006118
006121
006122
006123
006125
006126
006127
006130
006133
006136
006139
006144
006146
006148
006151
006152
006154
006156
006161
006163
006165
006167
006168
006169
006173
006176
006177
006182
006185
006186
006187
006190
006194
006195
006196
006198
006202
006204
006208
006210
006213
006215
006219
006222
006227
006228
006229
006232
006233
006238
006240
006244
006246
006247
006249
006250
006258
006263
006265
006266
006267
006269
006270
006272
006273
006274
006275
006276
006278
006280
006282
006286
006287
006288
006297
006300
006301
006302
006305
006306
006312
006314
006315
006316
006317
006321
006322
006324
006331
006332
006333
006334
006338
006339
006340
006342
006343
006344
006345
006348
006349
006351
006353
006354
006355
006356
006357
006360
006364
006366
006368
006369
006370
006371
006372
006377
006379
006380
006381
006385
006386
006388
006391
006393
006394
006395
006396
006403
006405
006406
006407
006409
006410
006411
006415
006416
006417
006420
006423
006424
006425
006426
006427
006433
006434
006435
006436
006437
006439
006440
006441
006442
006444
006445
006446
006451
006452
006453
006454
006462
006464
006465
006468
006469
006470
006472
006473
006474
006475
006477
006478
006481
006482
006483
006484
006486
006488
006491
006493
006496
006497
006498
006503
006505
006506
006507
006508
006512
006514
006515
006516
006517
006519
006520
006521
006524
006525
006529
006530
006531
006532
006533
006534
006535
006537
006540
006542
006548
006549
006551
006553
006555
006556
006558
006560
006561
006563
006565
006568
006569
006570
006574
006576
006577
006578
006581
006582
006583
006586
006588
006590
006592
006593
006595
006596
006597
006602
006603
006604
006611
006612
006613
006614
006618
006623
006624
006625
006626
006628
006629
006632
006633
006634
006636
006637
006638
006641
006643
006647
006649
006650
006651
006655
006656
006658
006659
006660
006664
006666
006667
006669
006670
006674
006676
006677
006678
006679
006682
006685
006686
006692
006693
006694
006695
006696
006698
006701
006703
006709
006710
006711
006712
006713
006714
006715
006719
006720
006723
006725
006726
006729
006731
006732
006733
006734
006737
006738
006741
006744
006745
006747
006751
006752
006753
006754
006755
006756
006758
006759
006760
006761
006762
006764
006765
006767
006768
006770
006771
006772
006773
006777
006778
006780
006781
006782
006783
006785
006786
006789
006791
006792
006794
006796
006797
006798
006800
006803
006804
006806
006807
006808
006811
006812
006813
006815
006816
006818
006819
006822
006828
006829
006832
006833
006836
006837
006841
006843
006844
006847
006849
006850
006852
006853
006854
006855
006856
006858
006860
006862
006863
006866
006868
006870
006872
006873
006874
006876
006879
006881
006882
006884
006885
006887
006889
006891
006895
006897
006898
006899
006900
006901
006903
006906
006907
006908
006910
006913
006914
006917
006922
006925
006928
006930
006936
006937
006938
006942
006943
006944
006945
006948
006950
006953
006954
006955
006956
006959
006960
006962
006964
006968
006971
006973
006977
006978
006980
006981
006982
006987
006989
006990
006992
006994
006997
006999
007000
007003
007005
007006
007008
007010
007011
007012
007014
007015
007016
007019
007022
007023
007026
007027
007028
007029
007030
007031
007032
007033
007034
007037
007038
007042
007043
007047
007048
007049
007052
007053
007055
007056
007059
007061
007063
007065
007067
007068
007069
007071
007072
007074
007076
007078
007079
007080
007081
007082
007083
007084
007085
007087
007088
007089
007091
007095
007098
007100
007103
007109
007110
007112
007115
007117
007119
007120
007122
007125
007130
007131
007132
007133
007135
007136
007138
007139
007144
007145
007146
007149
007154
007157
007158
007161
007162
007163
007164
007165
007166
007168
007169
007172
007174
007176
007177
007178
007180
007182
007183
007187
007194
007198
007199
007200
007201
007202
007204
007205
007207
007208
007210
007212
007214
007215
007217
007219
007221
007225
007227
007229
007230
007232
007233
007235
007238
007240
007242
007244
007246
007247
007252
007253
007255
007256
007258
007260
007261
007262
007265
007266
007267
007271
007272
007273
007274
007275
007277
007278
007279
007280
007283
007284
007287
007288
007289
007290
007291
007292
007294
007299
007300
007302
007303
007304
007309
007310
007311
007315
007318
007319
007322
007323
007325
007326
007327
007329
007330
007331
007336
007337
007339
007342
007343
007344
007345
007347
007349
007350
007351
007352
007353
007359
007360
007364
007369
007371
007374
007375
007376
007377
007380
007381
007382
007383
007384
007385
007389
007391
007395
007396
007397
007398
007401
007402
007403
007405
007407
007409
007410
007411
007412
007413
007415
007416
007419
007420
007421
007422
007423
007424
007426
007430
007433
007434
007435
007436
007437
007439
007440
007442
007445
007447
007448
007449
007450
007453
007456
007458
007462
007463
007464
007466
007467
007468
007469
007470
007473
007475
007477
007478
007480

================================================
FILE: tools/dataset.py
================================================
import os
import numpy as np
import torch.utils.data as torch_data
import kitti_utils
import cv2
from PIL import Image


USE_INTENSITY = False


class KittiDataset(torch_data.Dataset):
    def __init__(self, root_dir, split='train', mode='TRAIN'):
        self.split = split
        self.mode = mode
        self.classes = ['Car']
        is_test = self.split == 'test'
        self.imageset_dir = os.path.join(root_dir, 'KITTI', 'object', 'testing' if is_test else 'training')

        split_dir = os.path.join(root_dir, 'KITTI', 'ImageSets', split + '.txt')
        self.image_idx_list = [x.strip() for x in open(split_dir).readlines()]
        self.sample_id_list = [int(sample_id) for sample_id in self.image_idx_list]
        self.num_sample = self.image_idx_list.__len__()

        self.npoints = 16384

        self.image_dir = os.path.join(self.imageset_dir, 'image_2')
        self.lidar_dir = os.path.join(self.imageset_dir, 'velodyne')
        self.calib_dir = os.path.join(self.imageset_dir, 'calib')
        self.label_dir = os.path.join(self.imageset_dir, 'label_2')
        self.plane_dir = os.path.join(self.imageset_dir, 'planes')

    def get_image(self, idx):
        img_file = os.path.join(self.image_dir, '%06d.png' % idx)
        assert os.path.exists(img_file)
        return cv2.imread(img_file)  # (H, W, 3) BGR mode

    def get_image_shape(self, idx):
        img_file = os.path.join(self.image_dir, '%06d.png' % idx)
        assert os.path.exists(img_file)
        im = Image.open(img_file)
        width, height = im.size
        return height, width, 3

    def get_lidar(self, idx):
        lidar_file = os.path.join(self.lidar_dir, '%06d.bin' % idx)
        assert os.path.exists(lidar_file)
        return np.fromfile(lidar_file, dtype=np.float32).reshape(-1, 4)

    def get_calib(self, idx):
        calib_file = os.path.join(self.calib_dir, '%06d.txt' % idx)
        assert os.path.exists(calib_file)
        return kitti_utils.Calibration(calib_file)

    def get_label(self, idx):
        label_file = os.path.join(self.label_dir, '%06d.txt' % idx)
        assert os.path.exists(label_file)
        return kitti_utils.get_objects_from_label(label_file)

    @staticmethod
    def get_valid_flag(pts_rect, pts_img, pts_rect_depth, img_shape):
        val_flag_1 = np.logical_and(pts_img[:, 0] >= 0, pts_img[:, 0] < img_shape[1])
        val_flag_2 = np.logical_and(pts_img[:, 1] >= 0, pts_img[:, 1] < img_shape[0])
        val_flag_merge = np.logical_and(val_flag_1, val_flag_2)
        pts_valid_flag = np.logical_and(val_flag_merge, pts_rect_depth >= 0)
        return pts_valid_flag

    def filtrate_objects(self, obj_list):
        type_whitelist = self.classes
        if self.mode == 'TRAIN':
            type_whitelist = list(self.classes)
            if 'Car' in self.classes:
                type_whitelist.append('Van')

        valid_obj_list = []
        for obj in obj_list:
            if obj.cls_type not in type_whitelist:
                continue

            valid_obj_list.append(obj)
        return valid_obj_list

    def __len__(self):
        return len(self.sample_id_list)

    def __getitem__(self, index):
        sample_id = int(self.sample_id_list[index])
        calib = self.get_calib(sample_id)
        img_shape = self.get_image_shape(sample_id)
        pts_lidar = self.get_lidar(sample_id)

        # get valid point (projected points should be in image)
        pts_rect = calib.lidar_to_rect(pts_lidar[:, 0:3])
        pts_intensity = pts_lidar[:, 3]

        pts_img, pts_rect_depth = calib.rect_to_img(pts_rect)
        pts_valid_flag = self.get_valid_flag(pts_rect, pts_img, pts_rect_depth, img_shape)

        pts_rect = pts_rect[pts_valid_flag][:, 0:3]
        pts_intensity = pts_intensity[pts_valid_flag]

        if self.npoints < len(pts_rect):
            pts_depth = pts_rect[:, 2]
            pts_near_flag = pts_depth < 40.0
            far_idxs_choice = np.where(pts_near_flag == 0)[0]
            near_idxs = np.where(pts_near_flag == 1)[0]
            near_idxs_choice = np.random.choice(near_idxs, self.npoints - len(far_idxs_choice), replace=False)

            choice = np.concatenate((near_idxs_choice, far_idxs_choice), axis=0) \
                if len(far_idxs_choice) > 0 else near_idxs_choice
            np.random.shuffle(choice)
        else:
            choice = np.arange(0, len(pts_rect), dtype=np.int32)
            if self.npoints > len(pts_rect):
                extra_choice = np.random.choice(choice, self.npoints - len(pts_rect), replace=False)
                choice = np.concatenate((choice, extra_choice), axis=0)
            np.random.shuffle(choice)

        ret_pts_rect = pts_rect[choice, :]
        ret_pts_intensity = pts_intensity[choice] - 0.5  # translate intensity to [-0.5, 0.5]

        pts_features = [ret_pts_intensity.reshape(-1, 1)]
        ret_pts_features = np.concatenate(pts_features, axis=1) if pts_features.__len__() > 1 else pts_features[0]

        sample_info = {'sample_id': sample_id}

        if self.mode == 'TEST':
            if USE_INTENSITY:
                pts_input = np.concatenate((ret_pts_rect, ret_pts_features), axis=1)  # (N, C)
            else:
                pts_input = ret_pts_rect
            sample_info['pts_input'] = pts_input
            sample_info['pts_rect'] = ret_pts_rect
            sample_info['pts_features'] = ret_pts_features
            return sample_info

        gt_obj_list = self.filtrate_objects(self.get_label(sample_id))

        gt_boxes3d = kitti_utils.objs_to_boxes3d(gt_obj_list)

        # prepare input
        if USE_INTENSITY:
            pts_input = np.concatenate((ret_pts_rect, ret_pts_features), axis=1)  # (N, C)
        else:
            pts_input = ret_pts_rect

        # generate training labels
        cls_labels = self.generate_training_labels(ret_pts_rect, gt_boxes3d)
        sample_info['pts_input'] = pts_input
        sample_info['pts_rect'] = ret_pts_rect
        sample_info['cls_labels'] = cls_labels
        return sample_info

    @staticmethod
    def generate_training_labels(pts_rect, gt_boxes3d):
        cls_label = np.zeros((pts_rect.shape[0]), dtype=np.int32)
        gt_corners = kitti_utils.boxes3d_to_corners3d(gt_boxes3d, rotate=True)
        extend_gt_boxes3d = kitti_utils.enlarge_box3d(gt_boxes3d, extra_width=0.2)
        extend_gt_corners = kitti_utils.boxes3d_to_corners3d(extend_gt_boxes3d, rotate=True)
        for k in range(gt_boxes3d.shape[0]):
            box_corners = gt_corners[k]
            fg_pt_flag = kitti_utils.in_hull(pts_rect, box_corners)
            cls_label[fg_pt_flag] = 1

            # enlarge the bbox3d, ignore nearby points
            extend_box_corners = extend_gt_corners[k]
            fg_enlarge_flag = kitti_utils.in_hull(pts_rect, extend_box_corners)
            ignore_flag = np.logical_xor(fg_pt_flag, fg_enlarge_flag)
            cls_label[ignore_flag] = -1

        return cls_label

    def collate_batch(self, batch):
        batch_size = batch.__len__()
        ans_dict = {}

        for key in batch[0].keys():
            if isinstance(batch[0][key], np.ndarray):
                ans_dict[key] = np.concatenate([batch[k][key][np.newaxis, ...] for k in range(batch_size)], axis=0)

            else:
                ans_dict[key] = [batch[k][key] for k in range(batch_size)]
                if isinstance(batch[0][key], int):
                    ans_dict[key] = np.array(ans_dict[key], dtype=np.int32)
                elif isinstance(batch[0][key], float):
                    ans_dict[key] = np.array(ans_dict[key], dtype=np.float32)

        return ans_dict


================================================
FILE: tools/kitti_utils.py
================================================
import numpy as np
from scipy.spatial import Delaunay
import scipy


def cls_type_to_id(cls_type):
    type_to_id = {'Car': 1, 'Pedestrian': 2, 'Cyclist': 3, 'Van': 4}
    if cls_type not in type_to_id.keys():
        return -1
    return type_to_id[cls_type]


class Object3d(object):
    def __init__(self, line):
        label = line.strip().split(' ')
        self.src = line
        self.cls_type = label[0]
        self.cls_id = cls_type_to_id(self.cls_type)
        self.trucation = float(label[1])
        self.occlusion = float(label[2])  # 0:fully visible 1:partly occluded 2:largely occluded 3:unknown
        self.alpha = float(label[3])
        self.box2d = np.array((float(label[4]), float(label[5]), float(label[6]), float(label[7])), dtype=np.float32)
        self.h = float(label[8])
        self.w = float(label[9])
        self.l = float(label[10])
        self.pos = np.array((float(label[11]), float(label[12]), float(label[13])), dtype=np.float32)
        self.dis_to_cam = np.linalg.norm(self.pos)
        self.ry = float(label[14])
        self.score = float(label[15]) if label.__len__() == 16 else -1.0
        self.level_str = None
        self.level = self.get_obj_level()

    def get_obj_level(self):
        height = float(self.box2d[3]) - float(self.box2d[1]) + 1

        if height >= 40 and self.trucation <= 0.15 and self.occlusion <= 0:
            self.level_str = 'Easy'
            return 1  # Easy
        elif height >= 25 and self.trucation <= 0.3 and self.occlusion <= 1:
            self.level_str = 'Moderate'
            return 2  # Moderate
        elif height >= 25 and self.trucation <= 0.5 and self.occlusion <= 2:
            self.level_str = 'Hard'
            return 3  # Hard
        else:
            self.level_str = 'UnKnown'
            return 4

    def generate_corners3d(self):
        """
        generate corners3d representation for this object
        :return corners_3d: (8, 3) corners of box3d in camera coord
        """
        l, h, w = self.l, self.h, self.w
        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]

        R = np.array([[np.cos(self.ry), 0, np.sin(self.ry)],
                      [0, 1, 0],
                      [-np.sin(self.ry), 0, np.cos(self.ry)]])
        corners3d = np.vstack([x_corners, y_corners, z_corners])  # (3, 8)
        corners3d = np.dot(R, corners3d).T
        corners3d = corners3d + self.pos
        return corners3d

    def to_str(self):
        print_str = '%s %.3f %.3f %.3f box2d: %s hwl: [%.3f %.3f %.3f] pos: %s ry: %.3f' \
                     % (self.cls_type, self.trucation, self.occlusion, self.alpha, self.box2d, self.h, self.w, self.l,
                        self.pos, self.ry)
        return print_str

    def to_kitti_format(self):
        kitti_str = '%s %.2f %d %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f' \
                    % (self.cls_type, self.trucation, int(self.occlusion), self.alpha, self.box2d[0], self.box2d[1],
                       self.box2d[2], self.box2d[3], self.h, self.w, self.l, self.pos[0], self.pos[1], self.pos[2],
                       self.ry)
        return kitti_str


def get_calib_from_file(calib_file):
    with open(calib_file) as f:
        lines = f.readlines()

    obj = lines[2].strip().split(' ')[1:]
    P2 = np.array(obj, dtype=np.float32)
    obj = lines[3].strip().split(' ')[1:]
    P3 = np.array(obj, dtype=np.float32)
    obj = lines[4].strip().split(' ')[1:]
    R0 = np.array(obj, dtype=np.float32)
    obj = lines[5].strip().split(' ')[1:]
    Tr_velo_to_cam = np.array(obj, dtype=np.float32)

    return {'P2': P2.reshape(3, 4),
            'P3': P3.reshape(3, 4),
            'R0': R0.reshape(3, 3),
            'Tr_velo2cam': Tr_velo_to_cam.reshape(3, 4)}


class Calibration(object):
    def __init__(self, calib_file):
        if isinstance(calib_file, str):
            calib = get_calib_from_file(calib_file)
        else:
            calib = calib_file

        self.P2 = calib['P2']  # 3 x 4
        self.R0 = calib['R0']  # 3 x 3
        self.V2C = calib['Tr_velo2cam']  # 3 x 4

    def cart_to_hom(self, pts):
        """
        :param pts: (N, 3 or 2)
        :return pts_hom: (N, 4 or 3)
        """
        pts_hom = np.hstack((pts, np.ones((pts.shape[0], 1), dtype=np.float32)))
        return pts_hom

    def lidar_to_rect(self, pts_lidar):
        """
        :param pts_lidar: (N, 3)
        :return pts_rect: (N, 3)
        """
        pts_lidar_hom = self.cart_to_hom(pts_lidar)
        pts_rect = np.dot(pts_lidar_hom, np.dot(self.V2C.T, self.R0.T))
        return pts_rect

    def rect_to_img(self, pts_rect):
        """
        :param pts_rect: (N, 3)
        :return pts_img: (N, 2)
        """
        pts_rect_hom = self.cart_to_hom(pts_rect)
        pts_2d_hom = np.dot(pts_rect_hom, self.P2.T)
        pts_img = (pts_2d_hom[:, 0:2].T / pts_rect_hom[:, 2]).T  # (N, 2)
        pts_rect_depth = pts_2d_hom[:, 2] - self.P2.T[3, 2]  # depth in rect camera coord
        return pts_img, pts_rect_depth

    def lidar_to_img(self, pts_lidar):
        """
        :param pts_lidar: (N, 3)
        :return pts_img: (N, 2)
        """
        pts_rect = self.lidar_to_rect(pts_lidar)
        pts_img, pts_depth = self.rect_to_img(pts_rect)
        return pts_img, pts_depth


def get_objects_from_label(label_file):
    with open(label_file, 'r') as f:
        lines = f.readlines()
    objects = [Object3d(line) for line in lines]
    return objects


def objs_to_boxes3d(obj_list):
    boxes3d = np.zeros((obj_list.__len__(), 7), dtype=np.float32)
    for k, obj in enumerate(obj_list):
        boxes3d[k, 0:3], boxes3d[k, 3], boxes3d[k, 4], boxes3d[k, 5], boxes3d[k, 6] \
            = obj.pos, obj.h, obj.w, obj.l, obj.ry
    return boxes3d


def boxes3d_to_corners3d(boxes3d, rotate=True):
    """
    :param boxes3d: (N, 7) [x, y, z, h, w, l, ry]
    :param rotate:
    :return: corners3d: (N, 8, 3)
    """
    boxes_num = boxes3d.shape[0]
    h, w, l = boxes3d[:, 3], boxes3d[:, 4], boxes3d[:, 5]
    x_corners = np.array([l / 2., l / 2., -l / 2., -l / 2., l / 2., l / 2., -l / 2., -l / 2.], dtype=np.float32).T  # (N, 8)
    z_corners = np.array([w / 2., -w / 2., -w / 2., w / 2., w / 2., -w / 2., -w / 2., w / 2.], dtype=np.float32).T  # (N, 8)

    y_corners = np.zeros((boxes_num, 8), dtype=np.float32)
    y_corners[:, 4:8] = -h.reshape(boxes_num, 1).repeat(4, axis=1)  # (N, 8)

    if rotate:
        ry = boxes3d[:, 6]
        zeros, ones = np.zeros(ry.size, dtype=np.float32), np.ones(ry.size, dtype=np.float32)
        rot_list = np.array([[np.cos(ry), zeros, -np.sin(ry)],
                             [zeros,       ones,       zeros],
                             [np.sin(ry), zeros,  np.cos(ry)]])  # (3, 3, N)
        R_list = np.transpose(rot_list, (2, 0, 1))  # (N, 3, 3)

        temp_corners = np.concatenate((x_corners.reshape(-1, 8, 1), y_corners.reshape(-1, 8, 1),
                                       z_corners.reshape(-1, 8, 1)), axis=2)  # (N, 8, 3)
        rotated_corners = np.matmul(temp_corners, R_list)  # (N, 8, 3)
        x_corners, y_corners, z_corners = rotated_corners[:, :, 0], rotated_corners[:, :, 1], rotated_corners[:, :, 2]

    x_loc, y_loc, z_loc = boxes3d[:, 0], boxes3d[:, 1], boxes3d[:, 2]

    x = x_loc.reshape(-1, 1) + x_corners.reshape(-1, 8)
    y = y_loc.reshape(-1, 1) + y_corners.reshape(-1, 8)
    z = z_loc.reshape(-1, 1) + z_corners.reshape(-1, 8)

    corners = np.concatenate((x.reshape(-1, 8, 1), y.reshape(-1, 8, 1), z.reshape(-1, 8, 1)), axis=2)

    return corners.astype(np.float32)


def enlarge_box3d(boxes3d, extra_width):
    """
    :param boxes3d: (N, 7) [x, y, z, h, w, l, ry]
    """
    if isinstance(boxes3d, np.ndarray):
        large_boxes3d = boxes3d.copy()
    else:
        large_boxes3d = boxes3d.clone()
    large_boxes3d[:, 3:6] += extra_width * 2
    large_boxes3d[:, 1] += extra_width
    return large_boxes3d


def in_hull(p, hull):
    """
    :param p: (N, K) test points
    :param hull: (M, K) M corners of a box
    :return (N) bool
    """
    try:
        if not isinstance(hull, Delaunay):
            hull = Delaunay(hull)
        flag = hull.find_simplex(p) >= 0
    except scipy.spatial.qhull.QhullError:
        print('Warning: not a hull %s' % str(hull))
        flag = np.zeros(p.shape[0], dtype=np.bool)

    return flag


================================================
FILE: tools/pointnet2_msg.py
================================================
import torch
import torch.nn as nn
from pointnet2.pointnet2_modules import PointnetFPModule, PointnetSAModuleMSG
import pointnet2.pytorch_utils as pt_utils


def get_model(input_channels=0):
    return Pointnet2MSG(input_channels=input_channels)


NPOINTS = [4096, 1024, 256, 64]
RADIUS = [[0.1, 0.5], [0.5, 1.0], [1.0, 2.0], [2.0, 4.0]]
NSAMPLE = [[16, 32], [16, 32], [16, 32], [16, 32]]
MLPS = [[[16, 16, 32], [32, 32, 64]], [[64, 64, 128], [64, 96, 128]],
        [[128, 196, 256], [128, 196, 256]], [[256, 256, 512], [256, 384, 512]]]
FP_MLPS = [[128, 128], [256, 256], [512, 512], [512, 512]]
CLS_FC = [128]
DP_RATIO = 0.5


class Pointnet2MSG(nn.Module):
    def __init__(self, input_channels=6):
        super().__init__()

        self.SA_modules = nn.ModuleList()
        channel_in = input_channels

        skip_channel_list = [input_channels]
        for k in range(NPOINTS.__len__()):
            mlps = MLPS[k].copy()
            channel_out = 0
            for idx in range(mlps.__len__()):
                mlps[idx] = [channel_in] + mlps[idx]
                channel_out += mlps[idx][-1]

            self.SA_modules.append(
                PointnetSAModuleMSG(
                    npoint=NPOINTS[k],
                    radii=RADIUS[k],
                    nsamples=NSAMPLE[k],
                    mlps=mlps,
                    use_xyz=True,
                    bn=True
                )
            )
            skip_channel_list.append(channel_out)
            channel_in = channel_out

        self.FP_modules = nn.ModuleList()

        for k in range(FP_MLPS.__len__()):
            pre_channel = FP_MLPS[k + 1][-1] if k + 1 < len(FP_MLPS) else channel_out
            self.FP_modules.append(
                PointnetFPModule(mlp=[pre_channel + skip_channel_list[k]] + FP_MLPS[k])
            )

        cls_layers = []
        pre_channel = FP_MLPS[0][-1]
        for k in range(0, CLS_FC.__len__()):
            cls_layers.append(pt_utils.Conv1d(pre_channel, CLS_FC[k], bn=True))
            pre_channel = CLS_FC[k]
        cls_layers.append(pt_utils.Conv1d(pre_channel, 1, activation=None))
        cls_layers.insert(1, nn.Dropout(0.5))
        self.cls_layer = nn.Sequential(*cls_layers)

    def _break_up_pc(self, pc):
        xyz = pc[..., 0:3].contiguous()
        features = (
            pc[..., 3:].transpose(1, 2).contiguous()
            if pc.size(-1) > 3 else None
        )

        return xyz, features

    def forward(self, pointcloud: torch.cuda.FloatTensor):
        xyz, features = self._break_up_pc(pointcloud)

        l_xyz, l_features = [xyz], [features]
        for i in range(len(self.SA_modules)):
            li_xyz, li_features = self.SA_modules[i](l_xyz[i], l_features[i])
            l_xyz.append(li_xyz)
            l_features.append(li_features)

        for i in range(-1, -(len(self.FP_modules) + 1), -1):
            l_features[i - 1] = self.FP_modules[i](
                l_xyz[i - 1], l_xyz[i], l_features[i - 1], l_features[i]
            )

        pred_cls = self.cls_layer(l_features[0]).transpose(1, 2).contiguous()  # (B, N, 1)
        return pred_cls


================================================
FILE: tools/train_and_eval.py
================================================
import _init_path
import numpy as np
import os
import torch
import torch.nn as nn
import torch.optim as optim
import torch.optim.lr_scheduler as lr_sched
from torch.nn.utils import clip_grad_norm_
from torch.utils.data import DataLoader
import tensorboard_logger as tb_log
from dataset import KittiDataset
import argparse
import importlib

parser = argparse.ArgumentParser(description="Arg parser")
parser.add_argument("--batch_size", type=int, default=8)
parser.add_argument("--epochs", type=int, default=100)
parser.add_argument("--ckpt_save_interval", type=int, default=5)
parser.add_argument('--workers', type=int, default=4)
parser.add_argument("--mode", type=str, default='train')
parser.add_argument("--ckpt", type=str, default='None')

parser.add_argument("--net", type=str, default='pointnet2_msg')

parser.add_argument('--lr', type=float, default=0.002)
parser.add_argument('--lr_decay', type=float, default=0.2)
parser.add_argument('--lr_clip', type=float, default=0.000001)
parser.add_argument('--decay_step_list', type=list, default=[50, 70, 80, 90])
parser.add_argument('--weight_decay', type=float, default=0.001)

parser.add_argument("--output_dir", type=str, default='output')
parser.add_argument("--extra_tag", type=str, default='default')

args = parser.parse_args()

FG_THRESH = 0.3


def log_print(info, log_f=None):
    print(info)
    if log_f is not None:
        print(info, file=log_f)


class DiceLoss(nn.Module):
    def __init__(self, ignore_target=-1):
        super().__init__()
        self.ignore_target = ignore_target

    def forward(self, input, target):
        """
        :param input: (N), logit
        :param target: (N), {0, 1}
        :return:
        """
        input = torch.sigmoid(input.view(-1))
        target = target.float().view(-1)
        mask = (target != self.ignore_target).float()
        return 1.0 - (torch.min(input, target) * mask).sum() / torch.clamp((torch.max(input, target) * mask).sum(), min=1.0)


def train_one_epoch(model, train_loader, optimizer, epoch, lr_scheduler, total_it, tb_log, log_f):
    model.train()
    log_print('===============TRAIN EPOCH %d================' % epoch, log_f=log_f)
    loss_func = DiceLoss(ignore_target=-1)

    for it, batch in enumerate(train_loader):
        optimizer.zero_grad()

        pts_input, cls_labels = batch['pts_input'], batch['cls_labels']
        pts_input = torch.from_numpy(pts_input).cuda(non_blocking=True).float()
        cls_labels = torch.from_numpy(cls_labels).cuda(non_blocking=True).long().view(-1)

        pred_cls = model(pts_input)
        pred_cls = pred_cls.view(-1)

        loss = loss_func(pred_cls, cls_labels)
        loss.backward()
        clip_grad_norm_(model.parameters(), 1.0)
        optimizer.step()

        total_it += 1

        pred_class = (torch.sigmoid(pred_cls) > FG_THRESH)
        fg_mask = cls_labels > 0
        correct = ((pred_class.long() == cls_labels) & fg_mask).float().sum()
        union = fg_mask.sum().float() + (pred_class > 0).sum().float() - correct
        iou = correct / torch.clamp(union, min=1.0)

        cur_lr = lr_scheduler.get_lr()[0]
        tb_log.log_value('learning_rate', cur_lr, epoch)
        if tb_log is not None:
            tb_log.log_value('train_loss', loss, total_it)
            tb_log.log_value('train_fg_iou', iou, total_it)

        log_print('training epoch %d: it=%d/%d, total_it=%d, loss=%.5f, fg_iou=%.3f, lr=%f' %
                  (epoch, it, len(train_loader), total_it, loss.item(), iou.item(), cur_lr), log_f=log_f)

    return total_it


def eval_one_epoch(model, eval_loader, epoch, tb_log=None, log_f=None):
    model.train()
    log_print('===============EVAL EPOCH %d================' % epoch, log_f=log_f)

    iou_list = []
    for it, batch in enumerate(eval_loader):
        pts_input, cls_labels = batch['pts_input'], batch['cls_labels']
        pts_input = torch.from_numpy(pts_input).cuda(non_blocking=True).float()
        cls_labels = torch.from_numpy(cls_labels).cuda(non_blocking=True).long().view(-1)

        pred_cls = model(pts_input)
        pred_cls = pred_cls.view(-1)

        pred_class = (torch.sigmoid(pred_cls) > FG_THRESH)
        fg_mask = cls_labels > 0
        correct = ((pred_class.long() == cls_labels) & fg_mask).float().sum()
        union = fg_mask.sum().float() + (pred_class > 0).sum().float() - correct
        iou = correct / torch.clamp(union, min=1.0)

        iou_list.append(iou.item())
        log_print('EVAL: it=%d/%d, iou=%.3f' % (it, len(eval_loader), iou), log_f=log_f)

    iou_list = np.array(iou_list)
    avg_iou = iou_list.mean()
    if tb_log is not None:
        tb_log.log_value('eval_fg_iou', avg_iou, epoch)

    log_print('\nEpoch %d: Average IoU (samples=%d): %.6f' % (epoch, iou_list.__len__(), avg_iou), log_f=log_f)
    return avg_iou


def save_checkpoint(model, epoch, ckpt_name):
    if isinstance(model, torch.nn.DataParallel):
        model_state = model.module.state_dict()
    else:
        model_state = model.state_dict()

    state = {'epoch': epoch, 'model_state': model_state}
    ckpt_name = '{}.pth'.format(ckpt_name)
    torch.save(state, ckpt_name)


def load_checkpoint(model, filename):
    if os.path.isfile(filename):
        log_print("==> Loading from checkpoint %s" % filename)
        checkpoint = torch.load(filename)
        epoch = checkpoint['epoch']
        model.load_state_dict(checkpoint['model_state'])
        log_print("==> Done")
    else:
        raise FileNotFoundError

    return epoch


def train_and_eval(model, train_loader, eval_loader, tb_log, ckpt_dir, log_f):
    model.cuda()
    optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay)

    def lr_lbmd(cur_epoch):
        cur_decay = 1
        for decay_step in args.decay_step_list:
            if cur_epoch >= decay_step:
                cur_decay = cur_decay * args.lr_decay
        return max(cur_decay, args.lr_clip / args.lr)

    lr_scheduler = lr_sched.LambdaLR(optimizer, lr_lbmd)

    total_it = 0
    for epoch in range(1, args.epochs + 1):
        lr_scheduler.step(epoch)
        total_it = train_one_epoch(model, train_loader, optimizer, epoch, lr_scheduler, total_it, tb_log, log_f)

        if epoch % args.ckpt_save_interval == 0:
            with torch.no_grad():
                avg_iou = eval_one_epoch(model, eval_loader, epoch, tb_log, log_f)
                ckpt_name = os.path.join(ckpt_dir, 'checkpoint_epoch_%d' % epoch)
                save_checkpoint(model, epoch, ckpt_name)


if __name__ == '__main__':
    MODEL = importlib.import_module(args.net)  # import network module
    model = MODEL.get_model(input_channels=0)

    eval_set = KittiDataset(root_dir='./data', mode='EVAL', split='val')
    eval_loader = DataLoader(eval_set, batch_size=args.batch_size, shuffle=False, pin_memory=True,
                             num_workers=args.workers, collate_fn=eval_set.collate_batch)

    if args.mode == 'train':
        train_set = KittiDataset(root_dir='./data', mode='TRAIN', split='train')
        train_loader = DataLoader(train_set, batch_size=args.batch_size, shuffle=True, pin_memory=True,
                                  num_workers=args.workers, collate_fn=train_set.collate_batch)
        # output dir config
        output_dir = os.path.join(args.output_dir, args.extra_tag)
        os.makedirs(output_dir, exist_ok=True)
        tb_log.configure(os.path.join(output_dir, 'tensorboard'))
        ckpt_dir = os.path.join(output_dir, 'ckpt')
        os.makedirs(ckpt_dir, exist_ok=True)

        log_file = os.path.join(output_dir, 'log.txt')
        log_f = open(log_file, 'w')

        for key, val in vars(args).items():
            log_print("{:16} {}".format(key, val), log_f=log_f)

        # train and eval
        train_and_eval(model, train_loader, eval_loader, tb_log, ckpt_dir, log_f)
        log_f.close()
    elif args.mode == 'eval':
        epoch = load_checkpoint(model, args.ckpt)
        model.cuda()
        with torch.no_grad():
            avg_iou = eval_one_epoch(model, eval_loader, epoch)
    else:
        raise NotImplementedError