From: khemendra kumar <khemendra.kumar@huawei.com>
Date: Tue, 30 Mar 2021 16:58:49 +0000 (+0530)
Subject: pcb defect detetcion application
X-Git-Url: https://gerrit.akraino.org/r/gitweb?a=commitdiff_plain;h=a785567fb9acfc68536767d20f60ba917ae85aa1;p=ealt-edge.git

pcb defect detetcion application

Signed-off-by: khemendra kumar <khemendra.kumar@huawei.com>
Change-Id: I9aa05aa16cce339142b7e945ae670ab52ac9a66b
---

diff --git a/example-apps/PDD/pcb-defect-detection/01_missing_hole_01.jpg b/example-apps/PDD/pcb-defect-detection/01_missing_hole_01.jpg
new file mode 100755
index 0000000..2fa7d73
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/01_missing_hole_01.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/04_mouse_bite_10.jpg b/example-apps/PDD/pcb-defect-detection/04_mouse_bite_10.jpg
new file mode 100755
index 0000000..9671331
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/04_mouse_bite_10.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/Dockerfile b/example-apps/PDD/pcb-defect-detection/Dockerfile
new file mode 100644
index 0000000..8c4b018
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/Dockerfile
@@ -0,0 +1,148 @@
+#
+# Copyright 2020 Huawei Technologies Co., Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# Prepare stage for multistage image build
+## START OF STAGE0 ##
+# FROM python:3.6-slim-stretch
+# FROM python:3.9
+# FROM python:3.9-slim-buster
+# # CREATE APP USER ##
+
+FROM python:2.7
+
+# Set umask
+RUN sed -i "s|umask 022|umask 027|g" /etc/profile
+
+# Create the home directory for the new app user.
+RUN mkdir -p /usr/app
+RUN mkdir -p /usr/app/bin
+RUN mkdir -p /usr/app/data
+RUN mkdir -p /usr/app/help_utils
+RUN mkdir -p /usr/app/libs
+RUN mkdir -p /usr/app/output
+RUN mkdir -p /usr/app/results
+RUN mkdir -p /usr/app/tools
+
+RUN mkdir -p /usr/app/input_image
+RUN mkdir -p /usr/app/output_image
+RUN mkdir -p /usr/app/input_image/beijinglab
+RUN mkdir -p /usr/app/input_image/beijinglab/camera1
+RUN mkdir -p /usr/app/input_image/beijinglab/camera2
+RUN mkdir -p /usr/app/input_image/beijinglab/camera3
+RUN mkdir -p /usr/app/input_image/shenzhenlab
+RUN mkdir -p /usr/app/input_image/shenzhenlab/camera1
+RUN mkdir -p /usr/app/input_image/shenzhenlab/camera2
+RUN mkdir -p /usr/app/input_image/shenzhenlab/camera3
+RUN mkdir -p /usr/app/input_image/shanghailab
+RUN mkdir -p /usr/app/input_image/shanghailab/camera1
+RUN mkdir -p /usr/app/input_image/shanghailab/camera2
+RUN mkdir -p /usr/app/input_image/shanghailab/camera3
+#output image path
+RUN mkdir -p /usr/app/output_image/beijinglab
+RUN mkdir -p /usr/app/output_image/beijinglab/camera1
+RUN mkdir -p /usr/app/output_image/beijinglab/camera2
+RUN mkdir -p /usr/app/output_image/beijinglab/camera3
+RUN mkdir -p /usr/app/output_image/shenzhenlab
+RUN mkdir -p /usr/app/output_image/shenzhenlab/camera1
+RUN mkdir -p /usr/app/output_image/shenzhenlab/camera2
+RUN mkdir -p /usr/app/output_image/shenzhenlab/camera3
+RUN mkdir -p /usr/app/output_image/shanghailab
+RUN mkdir -p /usr/app/output_image/shanghailab/camera1
+RUN mkdir -p /usr/app/output_image/shanghailab/camera2
+RUN mkdir -p /usr/app/output_image/shanghailab/camera3
+
+# Set the home directory to our app user's home.
+ENV APP_HOME=/usr/app
+ENV UID=166
+ENV GID=166
+ENV USER_NAME=eguser
+ENV GROUP_NAME=eggroup
+ENV ENV="/etc/profile"
+ENV PYTHONUNBUFFERED=0
+
+# Create an app user so our program doesn't run as root.
+RUN apt-get -y update &&\
+    groupadd -r -g $GID $GROUP_NAME &&\
+    useradd -r -u $UID -g $GID -d $APP_HOME -s /sbin/nologin -c "Docker image user" $USER_NAME
+
+RUN apt-get install -y --fix-missing \
+    build-essential \
+    cmake \
+    gfortran \
+    git \
+    wget \
+    curl \
+    graphicsmagick \
+    libgraphicsmagick1-dev \
+    libavcodec-dev \
+    libavformat-dev \
+    libgtk2.0-dev \
+    libjpeg-dev \
+    liblapack-dev \
+    libswscale-dev \
+    pkg-config \
+    software-properties-common \
+    zip \
+    imagemagick \
+    && apt-get clean && rm -rf /tmp/* /var/tmp/*
+
+# Set the working directory.
+WORKDIR $APP_HOME
+
+# Copy the application & scripts
+COPY config.py requirements.txt run.py $APP_HOME/
+# Install requirements
+RUN pip install -r requirements.txt
+
+# Install requirements
+RUN pip install Pillow
+
+COPY data $APP_HOME/data/
+COPY help_utils $APP_HOME/help_utils/
+COPY libs $APP_HOME/libs/
+COPY output $APP_HOME/output/
+COPY results $APP_HOME/results/
+COPY tools $APP_HOME/tools/
+COPY input_image/1 $APP_HOME/input_image/beijinglab/camera1
+COPY input_image/2 $APP_HOME/input_image/shenzhenlab/camera1
+COPY input_image/3 $APP_HOME/input_image/shanghailab/camera1
+COPY input_image/4 $APP_HOME/input_image/beijinglab/camera2
+COPY input_image/5 $APP_HOME/input_image/beijinglab/camera3
+COPY input_image/6 $APP_HOME/input_image/shenzhenlab/camera2
+COPY input_image/7 $APP_HOME/input_image/shenzhenlab/camera3
+COPY input_image/8 $APP_HOME/input_image/shanghailab/camera2
+COPY input_image/9 $APP_HOME/input_image/shanghailab/camera3
+
+
+COPY configs/start.sh $APP_HOME/bin
+
+RUN chmod 750 $APP_HOME &&\
+    chmod -R 550 $APP_HOME/bin &&\
+    mkdir -p -m 750 $APP_HOME/log &&\
+    mkdir -p -m 700 $APP_HOME/ssl &&\
+    chown -R $USER_NAME:$GROUP_NAME $APP_HOME
+
+# Exposed port
+EXPOSE 9991
+
+# Change to the app user.
+# USER $USER_NAME
+
+# Install requirements
+#RUN pip install -r requirements.txt
+
+# Execute script & application
+ENTRYPOINT ["sh", "./bin/start.sh"]
diff --git a/example-apps/PDD/pcb-defect-detection/README.md b/example-apps/PDD/pcb-defect-detection/README.md
new file mode 100755
index 0000000..a29e1ef
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/README.md
@@ -0,0 +1,117 @@
+# PCB-defect-detection
+## Note 
+This project code is forked from https://github.com/DetectionTeamUCAS/FPN_Tensorflow. I have only made minor changes on this wonderful and clear project. Thanks for their perfect code. I can learn and apply it to a new problem. The Chinese blog is: https://blog.csdn.net/dlh_sycamore/article/details/87886198
+##  PCB defect dataset
+The Open Lab on Human Robot Interaction of Peking University has released the PCB defect dataset. If you need to do experiments on this dataset, please contact the dataset author. 
+
+You can download at http://robotics.pkusz.edu.cn/resources/dataset/. or https://www.dropbox.com/s/32kolsaa45z2mpj/PCB_DATASET.zip?dl=0
+
+
+6 types of defects are made by photoshop, a graphics editor published by Adobe Systems. The defects defined in the dataset are: missing hole, mouse bite, open circuit, short, spur, and spurious copper. 
+For example:
+
+![1](a(missinghole).png)
+### Dataset Update
+The paper of this project will be update.
+However, the defect images of raw dataset are high-resolution. 
+With the respect of such small dataset, data augmentation techniques are adopted before data training. The images are then cropped
+into 600 × 600 sub-images, forming our training set and testing set with 9920 and 2508 images, respectively.
+
+### Some instructions: 
+
+1、This augmented dataset is privately owned, if you want to use it in your paper, please contact me.
+
+2、If you have questions, please open an issue, I will reply as soon as possible. If you don't have some difficult problem about this project, maybe you **don't need** to send me an email and add wechat, just open an issue.
+
+3、Of course, if you have other research questions like dataset and defect detection, welcome to send me an email.
+
+4、If you use our code, please access this paper and cite: 
+Ding, Runwei, et al. "TDD-Net: A Tiny Defect Detection Network for Printed Circuit Boards." CAAI Transactions on Intelligence Technology (https://ieeexplore.ieee.org/document/8757220)(2019).
+
+5、Chinese Blog: https://blog.csdn.net/dlh_sycamore/article/details/87886198
+
+## Download Model
+Please download [resnet50_v1](http://download.tensorflow.org/models/resnet_v1_50_2016_08_28.tar.gz)、[resnet101_v1](http://download.tensorflow.org/models/resnet_v1_101_2016_08_28.tar.gz) pre-trained models on Imagenet, put it to $PATH_ROOT/data/pretrained_weights. 
+## My Development Environment
+1、python2.7 (anaconda recommend)             
+2、CUDA Version 8.0.44 , CUDNN=5.1.10           
+3、[opencv(cv2)](https://pypi.org/project/opencv-python/)    
+4、[tfplot](https://github.com/wookayin/tensorflow-plot)             
+5、tensorflow == 1.121 
+
+## Compile
+```  
+cd $PATH_ROOT/libs/box_utils/cython_utils
+python setup.py build_ext --inplace
+```
+
+## Demo(available)
+
+Then download the corresponding weights:
+
+For Baiduyun: [weights](https://pan.baidu.com/s/1rvHjihG1fL499SqU28Nang). code：shac 
+
+For Google driver: [weights](https://drive.google.com/drive/folders/1oEHrEslnM5DBKB-610j-gO-x9-e90VwR?usp=sharing)
+
+
+And then put the trained weights into 
+```
+TRAINED_CKPT = os.path.join(ROOT_PATH, 'output/trained_weights')
+```
+It depends on your project path. Please read '$PATH_ROOT/libs/configs/cfgs.py'.
+
+```   
+cd $PATH_ROOT/tools
+python inference.py --data_dir='/PATH/TO/THE/TO/BE/DETECTED/IMAGES/' 
+                    --save_dir='/PATH/TO/SAVE/RESULTS/' 
+                    --GPU='0'
+```
+After running this code, you will get the detected image in your 'save_dir' path.
+
+Why didn't you get the correct output image when run the inference.py?
+
+**Note!!! If you didn't load the correct checkpoint but the pretrain model, you need to change the checkpoint file (FPN_Res101_0117_OHEM/checkpoint), because this file contains the wrong path, and you need to change it with your file path!!!**
+
+## Train
+If you want to train your own data, please follow this project: https://github.com/DetectionTeamUCAS/FPN_Tensorflow
+
+1、Select a configuration file in the folder ($PATH_ROOT/libs/configs/) and copy its contents into cfgs.py. Modify parameters (such as CLASS_NUM, DATASET_NAME, VERSION, etc.) in $PATH_ROOT/libs/configs/cfgs.py    
+
+2、Generate train and test floder
+
+```  
+cd $PATH_ROOT/data/io/  
+python divide_data.py 
+```    
+You should check the image_path and xml_path in the 'divide_data.py'
+
+2、Make tfrecord 
+
+(1)Modify parameters (such as VOC_dir, xml_dir, image_dir, dataset, etc.) in $PATH_ROOT/data/io/convert_data_to_tfrecord.py   
+```  
+cd $PATH_ROOT/data/io/  
+python convert_data_to_tfrecord.py 
+```     
+
+3、Train
+```  
+cd $PATH_ROOT/tools
+python train.py
+```
+
+## Eval
+```  
+cd $PATH_ROOT/tools
+python eval.py --eval_imgs='/PATH/TO/THE/TO/BE/EVALED/IMAGES/'  
+               --annotation_dir='/PATH/TO/TEST/ANNOTATION/'
+               --GPU='0'
+```   
+After running this code, you will get the precision, recall and AP of per defect type.
+
+## Some results 
+[the more results](https://github.com/Ixiaohuihuihui/PCB-defect-detection/tree/master/tools/inference_results)
+![1](01_missing_hole_01.jpg)
+![2](04_mouse_bite_10.jpg)
+
+## The Precision and Recall curve (PR)
+![3](TDD_results.jpg)
diff --git a/example-apps/PDD/pcb-defect-detection/TDD_results.jpg b/example-apps/PDD/pcb-defect-detection/TDD_results.jpg
new file mode 100755
index 0000000..77de1fd
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/TDD_results.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/a(missinghole).png b/example-apps/PDD/pcb-defect-detection/a(missinghole).png
new file mode 100755
index 0000000..b38fed5
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/a(missinghole).png differ
diff --git a/example-apps/PDD/pcb-defect-detection/config.py b/example-apps/PDD/pcb-defect-detection/config.py
new file mode 100644
index 0000000..6a177f3
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/config.py
@@ -0,0 +1,36 @@
+#
+# Copyright 2020 Huawei Technologies Co., Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+import os
+
+# [Server Configurations]
+server_port = 9991
+# server_address = os.environ.get('LISTEN_IP')
+server_address = "0.0.0.0"
+
+# [SSL Configurations]
+ssl_enabled = False
+ssl_protocol = "TLSv1.2"
+ssl_ciphers = ["TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
+               "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
+               "TLS_ECDHE_RSA_WITH_AES_-p 127.0.0.1:80:8080/tcp256_GCM_SHA384",
+               "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384"]
+ssl_certfilepath = "/usr/app/ssl/server_tls.crt"
+ssl_keyfilepath = "/usr/app/ssl/server_tls.key"
+ssl_cacertpath = "/usr/app/ssl/ca.crt"
+ssl_server_name = os.environ.get('SERVER_NAME', "ealtedge")
+
+
diff --git a/example-apps/PDD/pcb-defect-detection/configs/start.sh b/example-apps/PDD/pcb-defect-detection/configs/start.sh
new file mode 100644
index 0000000..2513297
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/configs/start.sh
@@ -0,0 +1,47 @@
+#!/bin/bash
+# Copyright 2020 Huawei Technologies Co., Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Validates if ip is valid
+validate_ip()
+{
+ ip_var="$1"
+    # checks if variable is unset
+ if [ -z "$ip_var" ] ; then
+    echo "ip is not set"
+    return 1
+ fi
+
+ if ! echo "$ip_var" | grep -qE '^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.)' ; then
+   return 1
+ fi
+ return 0
+}
+
+validate_name() {
+  hostname="$1"
+  len="${#hostname}"
+  if [ "${len}" -gt "64" ]; then
+    return 1
+  fi
+  if ! echo "$hostname" | grep -qE '^[a-zA-Z0-9]*$|^[a-zA-Z0-9][a-zA-Z0-9_\-]*[a-zA-Z0-9]$'; then
+    return 1
+  fi
+  return 0
+}
+
+echo "Running pcb defect detection App"
+umask 0027
+cd /usr/app || exit
+python -u run.py
diff --git a/example-apps/PDD/pcb-defect-detection/data/__init__.py b/example-apps/PDD/pcb-defect-detection/data/__init__.py
new file mode 100755
index 0000000..e69de29
diff --git a/example-apps/PDD/pcb-defect-detection/data/io/__init__.py b/example-apps/PDD/pcb-defect-detection/data/io/__init__.py
new file mode 100755
index 0000000..e69de29
diff --git a/example-apps/PDD/pcb-defect-detection/data/io/convert_data_to_tfrecord.py b/example-apps/PDD/pcb-defect-detection/data/io/convert_data_to_tfrecord.py
new file mode 100755
index 0000000..17bb8d6
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/data/io/convert_data_to_tfrecord.py
@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+from __future__ import division, print_function, absolute_import
+import sys
+sys.path.append('../../')
+import xml.etree.cElementTree as ET
+import numpy as np
+import tensorflow as tf
+import glob
+import cv2
+from libs.label_name_dict.label_dict import *
+from help_utils.tools import *
+
+#tf.app.flags.DEFINE_string('VOC_dir', '/home/root1/My_Work/Akraino/MEC_BP/Use_cases/PCB_Demo/Tiny-Defect-Detection-for-PCB/data/pcb_train/PCB_DATASET/', 'Voc dir')
+tf.app.flags.DEFINE_string('VOC_dir', '/home/root1/My_Work/Akraino/MEC_BP/Use_cases/PCB_Demo/Tiny-Defect-Detection-for-PCB/data/pcb_test/PCB_DATASET/', 'Voc dir')
+tf.app.flags.DEFINE_string('xml_dir', 'Annotations/Missing_hole', 'xml dir')
+tf.app.flags.DEFINE_string('image_dir', 'images/Missing_hole', 'image dir')
+tf.app.flags.DEFINE_string('save_name', 'test', 'save name')
+tf.app.flags.DEFINE_string('save_dir', '../tfrecord/', 'save name')
+tf.app.flags.DEFINE_string('img_format', '.jpg', 'format of image')
+tf.app.flags.DEFINE_string('dataset', 'pcb', 'dataset')
+FLAGS = tf.app.flags.FLAGS
+
+
+def _int64_feature(value):
+    return tf.train.Feature(int64_list=tf.train.Int64List(value=[value]))
+
+
+def _bytes_feature(value):
+    return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))
+
+
+def read_xml_gtbox_and_label(xml_path):
+    """
+    :param xml_path: the path of voc xml
+    :return: a list contains gtboxes and labels, shape is [num_of_gtboxes, 9],
+           and has [x1, y1, x2, y2, x3, y3, x4, y4, label] in a per row
+    """
+
+    tree = ET.parse(xml_path)
+    root = tree.getroot()
+    img_width = None
+    img_height = None
+    box_list = []
+    for child_of_root in root:
+        # if child_of_root.tag == 'filename':
+        #     assert child_of_root.text == xml_path.split('/')[-1].split('.')[0] \
+        #                                  + FLAGS.img_format, 'xml_name and img_name cannot match'
+
+        if child_of_root.tag == 'size':
+            for child_item in child_of_root:
+                if child_item.tag == 'width':
+                    img_width = int(child_item.text)
+                if child_item.tag == 'height':
+                    img_height = int(child_item.text)
+
+        if child_of_root.tag == 'object':
+            label = None
+            for child_item in child_of_root:
+                if child_item.tag == 'name':
+                    label = NAME_LABEL_MAP[child_item.text]
+                if child_item.tag == 'bndbox':
+                    tmp_box = []
+                    for node in child_item:
+                        tmp_box.append(int(node.text))
+                    assert label is not None, 'label is none, error'
+                    tmp_box.append(label)
+                    box_list.append(tmp_box)
+
+    gtbox_label = np.array(box_list, dtype=np.int32)
+
+    return img_height, img_width, gtbox_label
+
+
+def convert_pascal_to_tfrecord():
+    xml_path = FLAGS.VOC_dir + FLAGS.xml_dir
+    image_path = FLAGS.VOC_dir + FLAGS.image_dir
+    save_path = FLAGS.save_dir + FLAGS.dataset + '_' + FLAGS.save_name + '.tfrecord'
+    mkdir(FLAGS.save_dir)
+
+    # writer_options = tf.python_io.TFRecordOptions(tf.python_io.TFRecordCompressionType.ZLIB)
+    # writer = tf.python_io.TFRecordWriter(path=save_path, options=writer_options)
+    writer = tf.python_io.TFRecordWriter(path=save_path)
+    for count, xml in enumerate(glob.glob(xml_path + '/*.xml')):
+        # to avoid path error in different development platform
+        xml = xml.replace('\\', '/')
+
+        img_name = xml.split('/')[-1].split('.')[0] + FLAGS.img_format
+        img_path = image_path + '/' + img_name
+
+        if not os.path.exists(img_path):
+            print('{} is not exist!'.format(img_path))
+            continue
+
+        img_height, img_width, gtbox_label = read_xml_gtbox_and_label(xml)
+
+        # img = np.array(Image.open(img_path))
+        img = cv2.imread(img_path)[:, :, ::-1]
+
+        feature = tf.train.Features(feature={
+            # do not need encode() in linux
+            # 'img_name': _bytes_feature(img_name.encode()),
+            'img_name': _bytes_feature(img_name.encode()),
+            'img_height': _int64_feature(img_height),
+            'img_width': _int64_feature(img_width),
+            'img': _bytes_feature(img.tostring()),
+            'gtboxes_and_label': _bytes_feature(gtbox_label.tostring()),
+            'num_objects': _int64_feature(gtbox_label.shape[0])
+        })
+
+        example = tf.train.Example(features=feature)
+
+        writer.write(example.SerializeToString())
+
+        view_bar('Conversion progress', count + 1, len(glob.glob(xml_path + '/*.xml')))
+
+    print('\nConversion is complete!')
+
+
+if __name__ == '__main__':
+    # xml_path = '../data/dataset/VOCdevkit/VOC2007/Annotations/000005.xml'
+    # read_xml_gtbox_and_label(xml_path)
+
+    convert_pascal_to_tfrecord()
diff --git a/example-apps/PDD/pcb-defect-detection/data/io/divide_data.py b/example-apps/PDD/pcb-defect-detection/data/io/divide_data.py
new file mode 100755
index 0000000..64821e5
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/data/io/divide_data.py
@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import, division, print_function
+
+import math
+import os
+import random
+import shutil
+import sys
+
+sys.path.append('../../')
+
+from libs.configs import cfgs
+
+
+def mkdir(path):
+  if not os.path.exists(path):
+    os.makedirs(path)
+
+
+divide_rate = 0.8
+
+image_path = os.path.join(cfgs.ROOT_PATH, '{}/JPEGImages'.format(cfgs.DATASET_NAME))
+xml_path = os.path.join(cfgs.ROOT_PATH, '{}/Annotations'.format(cfgs.DATASET_NAME))
+
+image_list = os.listdir(image_path)
+
+image_name = [n.split('.')[0] for n in image_list]
+
+random.shuffle(image_name)
+
+train_image = image_name[:int(math.ceil(len(image_name)) * divide_rate)]
+test_image = image_name[int(math.ceil(len(image_name)) * divide_rate):]
+
+image_output_train = os.path.join(
+    cfgs.ROOT_PATH, '{}_train/JPEGImages'.format(cfgs.DATASET_NAME))
+mkdir(image_output_train)
+image_output_test = os.path.join(
+    cfgs.ROOT_PATH, '{}_test/JPEGImages'.format(cfgs.DATASET_NAME))
+mkdir(image_output_test)
+
+xml_train = os.path.join(cfgs.ROOT_PATH, '{}_train/Annotations'.format(cfgs.DATASET_NAME))
+mkdir(xml_train)
+xml_test = os.path.join(cfgs.ROOT_PATH, '{}_test/Annotations'.format(cfgs.DATASET_NAME))
+mkdir(xml_test)
+
+
+count = 0
+for i in train_image:
+  shutil.copy(os.path.join(image_path, i + '.jpg'), image_output_train)
+  if os.path.exists(os.path.join(xml_path, i + '.xml')):
+    shutil.copy(os.path.join(xml_path, i + '.xml'), xml_train)
+  if count % 1000 == 0:
+    print("process step {}".format(count))
+  count += 1
+
+for i in test_image:
+  shutil.copy(os.path.join(image_path, i + '.jpg'), image_output_test)
+  shutil.copy(os.path.join(xml_path, i + '.xml'), xml_test)
+  if count % 1000 == 0:
+    print("process step {}".format(count))
+  count += 1
diff --git a/example-apps/PDD/pcb-defect-detection/data/io/image_preprocess.py b/example-apps/PDD/pcb-defect-detection/data/io/image_preprocess.py
new file mode 100755
index 0000000..7d85395
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/data/io/image_preprocess.py
@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import
+from __future__ import print_function
+from __future__ import division
+
+import tensorflow as tf
+
+import numpy as np
+
+
+def max_length_limitation(length, length_limitation):
+    return tf.cond(tf.less(length, length_limitation),
+                   true_fn=lambda: length,
+                   false_fn=lambda: length_limitation)
+
+def short_side_resize(img_tensor, gtboxes_and_label, target_shortside_len, length_limitation=1200):
+    '''
+
+    :param img_tensor:[h, w, c], gtboxes_and_label:[-1, 5].  gtboxes: [xmin, ymin, xmax, ymax]
+    :param target_shortside_len:
+    :param length_limitation: set max length to avoid OUT OF MEMORY
+    :return:
+    '''
+    img_h, img_w = tf.shape(img_tensor)[0], tf.shape(img_tensor)[1]
+    new_h, new_w = tf.cond(tf.less(img_h, img_w),
+                           true_fn=lambda: (target_shortside_len,
+                                            max_length_limitation(target_shortside_len * img_w // img_h, length_limitation)),
+                           false_fn=lambda: (max_length_limitation(target_shortside_len * img_h // img_w, length_limitation),
+                                             target_shortside_len))
+
+    img_tensor = tf.expand_dims(img_tensor, axis=0)
+    img_tensor = tf.image.resize_bilinear(img_tensor, [new_h, new_w])
+
+    xmin, ymin, xmax, ymax, label = tf.unstack(gtboxes_and_label, axis=1)
+
+    new_xmin, new_ymin = xmin * new_w // img_w, ymin * new_h // img_h
+    new_xmax, new_ymax = xmax * new_w // img_w, ymax * new_h // img_h
+    img_tensor = tf.squeeze(img_tensor, axis=0)  # ensure image tensor rank is 3
+
+    return img_tensor, tf.transpose(tf.stack([new_xmin, new_ymin, new_xmax, new_ymax, label], axis=0))
+
+
+def short_side_resize_for_inference_data(img_tensor, target_shortside_len, length_limitation=1200, is_resize=True):
+    if is_resize:
+      img_h, img_w = tf.shape(img_tensor)[0], tf.shape(img_tensor)[1]
+
+      new_h, new_w = tf.cond(tf.less(img_h, img_w),
+                             true_fn=lambda: (target_shortside_len,
+                                              max_length_limitation(target_shortside_len * img_w // img_h, length_limitation)),
+                             false_fn=lambda: (max_length_limitation(target_shortside_len * img_h // img_w, length_limitation),
+                                               target_shortside_len))
+
+      img_tensor = tf.expand_dims(img_tensor, axis=0)
+      img_tensor = tf.image.resize_bilinear(img_tensor, [new_h, new_w])
+
+      img_tensor = tf.squeeze(img_tensor, axis=0)  # ensure image tensor rank is 3
+    return img_tensor
+
+def flip_left_to_right(img_tensor, gtboxes_and_label):
+
+    h, w = tf.shape(img_tensor)[0], tf.shape(img_tensor)[1]
+
+    img_tensor = tf.image.flip_left_right(img_tensor)
+
+    xmin, ymin, xmax, ymax, label = tf.unstack(gtboxes_and_label, axis=1)
+    new_xmax = w - xmin
+    new_xmin = w - xmax
+
+    return img_tensor, tf.transpose(tf.stack([new_xmin, ymin, new_xmax, ymax, label], axis=0))
+
+def random_flip_left_right(img_tensor, gtboxes_and_label):
+    img_tensor, gtboxes_and_label= tf.cond(tf.less(tf.random_uniform(shape=[], minval=0, maxval=1), 0.5),
+                                            lambda: flip_left_to_right(img_tensor, gtboxes_and_label),
+                                            lambda: (img_tensor, gtboxes_and_label))
+
+    return img_tensor,  gtboxes_and_label
+
+
+
diff --git a/example-apps/PDD/pcb-defect-detection/data/io/read_tfrecord.py b/example-apps/PDD/pcb-defect-detection/data/io/read_tfrecord.py
new file mode 100755
index 0000000..8f1605f
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/data/io/read_tfrecord.py
@@ -0,0 +1,99 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import
+from __future__ import print_function
+from __future__ import division
+
+import numpy as np
+import tensorflow as tf
+import os
+from data.io import image_preprocess
+from libs.configs import cfgs
+
+def read_single_example_and_decode(filename_queue):
+
+    # tfrecord_options = tf.python_io.TFRecordOptions(tf.python_io.TFRecordCompressionType.ZLIB)
+
+    # reader = tf.TFRecordReader(options=tfrecord_options)
+    reader = tf.TFRecordReader()
+    _, serialized_example = reader.read(filename_queue)
+
+    features = tf.parse_single_example(
+        serialized=serialized_example,
+        features={
+            'img_name': tf.FixedLenFeature([], tf.string),
+            'img_height': tf.FixedLenFeature([], tf.int64),
+            'img_width': tf.FixedLenFeature([], tf.int64),
+            'img': tf.FixedLenFeature([], tf.string),
+            'gtboxes_and_label': tf.FixedLenFeature([], tf.string),
+            'num_objects': tf.FixedLenFeature([], tf.int64)
+        }
+    )
+    img_name = features['img_name']
+    img_height = tf.cast(features['img_height'], tf.int32)
+    img_width = tf.cast(features['img_width'], tf.int32)
+    img = tf.decode_raw(features['img'], tf.uint8)
+
+    img = tf.reshape(img, shape=[img_height, img_width, 3])
+
+    gtboxes_and_label = tf.decode_raw(features['gtboxes_and_label'], tf.int32)
+    gtboxes_and_label = tf.reshape(gtboxes_and_label, [-1, 5])
+
+    num_objects = tf.cast(features['num_objects'], tf.int32)
+    return img_name, img, gtboxes_and_label, num_objects
+
+
+def read_and_prepocess_single_img(filename_queue, shortside_len, is_training):
+
+    img_name, img, gtboxes_and_label, num_objects = read_single_example_and_decode(filename_queue)
+
+    img = tf.cast(img, tf.float32)
+
+    if is_training:
+        img, gtboxes_and_label = image_preprocess.short_side_resize(img_tensor=img, gtboxes_and_label=gtboxes_and_label,
+                                                                    target_shortside_len=shortside_len,
+                                                                    length_limitation=cfgs.IMG_MAX_LENGTH)
+        img, gtboxes_and_label = image_preprocess.random_flip_left_right(img_tensor=img,
+                                                                         gtboxes_and_label=gtboxes_and_label)
+
+    else:
+        img, gtboxes_and_label = image_preprocess.short_side_resize(img_tensor=img, gtboxes_and_label=gtboxes_and_label,
+                                                                    target_shortside_len=shortside_len,
+                                                                    length_limitation=cfgs.IMG_MAX_LENGTH)
+    img = img - tf.constant([[cfgs.PIXEL_MEAN]])  # sub pixel mean at last
+    return img_name, img, gtboxes_and_label, num_objects
+
+
+def next_batch(dataset_name, batch_size, shortside_len, is_training):
+    '''
+    :return:
+    img_name_batch: shape(1, 1)
+    img_batch: shape:(1, new_imgH, new_imgW, C)
+    gtboxes_and_label_batch: shape(1, Num_Of_objects, 5] .each row is [x1, y1, x2, y2, label]
+    '''
+    assert batch_size == 1, "we only support batch_size is 1.We may support large batch_size in the future"
+
+    if dataset_name not in ['ship', 'spacenet', 'pascal', 'coco','pcb']:
+        raise ValueError('dataSet name must be in pascal, coco spacenet and ship')
+
+    if is_training:
+        pattern = os.path.join('../data/tfrecord', dataset_name + '_train*')
+    else:
+        pattern = os.path.join('../data/tfrecord', dataset_name + '_test*')
+
+    print('tfrecord path is -->', os.path.abspath(pattern))
+
+    filename_tensorlist = tf.train.match_filenames_once(pattern)
+
+    filename_queue = tf.train.string_input_producer(filename_tensorlist)
+
+    img_name, img, gtboxes_and_label, num_obs = read_and_prepocess_single_img(filename_queue, shortside_len,
+                                                                              is_training=is_training)
+    img_name_batch, img_batch, gtboxes_and_label_batch, num_obs_batch = \
+        tf.train.batch(
+                       [img_name, img, gtboxes_and_label, num_obs],
+                       batch_size=batch_size,
+                       capacity=1,
+                       num_threads=1,
+                       dynamic_pad=True)
+    return img_name_batch, img_batch, gtboxes_and_label_batch, num_obs_batch
diff --git a/example-apps/PDD/pcb-defect-detection/data/io/test.ttf b/example-apps/PDD/pcb-defect-detection/data/io/test.ttf
new file mode 100755
index 0000000..4c22885
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/data/io/test.ttf differ
diff --git a/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/Makefile b/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/Makefile
new file mode 100755
index 0000000..ab5e3d2
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/Makefile
@@ -0,0 +1,9 @@
+all:
+    # install pycocotools locally
+	python setup.py build_ext --inplace
+	rm -rf build
+
+install:
+	# install pycocotools to the Python site-packages
+	python setup.py build_ext install
+	rm -rf build
\ No newline at end of file
diff --git a/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/__init__.py b/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/__init__.py
new file mode 100755
index 0000000..e69de29
diff --git a/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/pycocoDemo.ipynb b/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/pycocoDemo.ipynb
new file mode 100755
index 0000000..c68f242
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/pycocoDemo.ipynb
@@ -0,0 +1,272 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "from pycocotools.coco import COCO\n",
+    "import numpy as np\n",
+    "import skimage.io as io\n",
+    "import matplotlib.pyplot as plt\n",
+    "import pylab\n",
+    "pylab.rcParams['figure.figsize'] = (8.0, 10.0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "dataDir='..'\n",
+    "dataType='val2017'\n",
+    "annFile='{}/annotations/instances_{}.json'.format(dataDir,dataType)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "loading annotations into memory...\n",
+      "Done (t=0.81s)\n",
+      "creating index...\n",
+      "index created!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# initialize COCO api for instance annotations\n",
+    "coco=COCO(annFile)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "COCO categories: \n",
+      "person bicycle car motorcycle airplane bus train truck boat traffic light fire hydrant stop sign parking meter bench bird cat dog horse sheep cow elephant bear zebra giraffe backpack umbrella handbag tie suitcase frisbee skis snowboard sports ball kite baseball bat baseball glove skateboard surfboard tennis racket bottle wine glass cup fork knife spoon bowl banana apple sandwich orange broccoli carrot hot dog pizza donut cake chair couch potted plant bed dining table toilet tv laptop mouse remote keyboard cell phone microwave oven toaster sink refrigerator book clock vase scissors teddy bear hair drier toothbrush\n",
+      "\n",
+      "COCO supercategories: \n",
+      "outdoor food indoor appliance sports person animal vehicle furniture accessory electronic kitchen\n"
+     ]
+    }
+   ],
+   "source": [
+    "# display COCO categories and supercategories\n",
+    "cats = coco.loadCats(coco.getCatIds())\n",
+    "nms=[cat['name'] for cat in cats]\n",
+    "print('COCO categories: \\n{}\\n'.format(' '.join(nms)))\n",
+    "\n",
+    "nms = set([cat['supercategory'] for cat in cats])\n",
+    "print('COCO supercategories: \\n{}'.format(' '.join(nms)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# get all images containing given categories, select one at random\n",
+    "catIds = coco.getCatIds(catNms=['person','dog','skateboard']);\n",
+    "imgIds = coco.getImgIds(catIds=catIds );\n",
+    "imgIds = coco.getImgIds(imgIds = [324158])\n",
+    "img = coco.loadImgs(imgIds[np.random.randint(0,len(imgIds))])[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfAAAAFNCAYAAAD/+D1NAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSUVORK5CYII=\n",
+      "text/plain": [
+       "<matplotlib.figure.Figure at 0x110703450>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# load and display image\n",
+    "# I = io.imread('%s/images/%s/%s'%(dataDir,dataType,img['file_name']))\n",
+    "# use url to load image\n",
+    "I = io.imread(img['coco_url'])\n",
+    "plt.axis('off')\n",
+    "plt.imshow(I)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfAAAAFNCAYAAAD/+D1NAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
+      "text/plain": [
+       "<matplotlib.figure.Figure at 0x11f12e9d0>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# load and display instance annotations\n",
+    "plt.imshow(I); plt.axis('off')\n",
+    "annIds = coco.getAnnIds(imgIds=img['id'], catIds=catIds, iscrowd=None)\n",
+    "anns = coco.loadAnns(annIds)\n",
+    "coco.showAnns(anns)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "loading annotations into memory...\n",
+      "Done (t=0.58s)\n",
+      "creating index...\n",
+      "index created!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# initialize COCO api for person keypoints annotations\n",
+    "annFile = '{}/annotations/person_keypoints_{}.json'.format(dataDir,dataType)\n",
+    "coco_kps=COCO(annFile)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfAAAAFNCAYAAAD/+D1NAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAI+JiYmJiTmGxAE8JiYmJibmGPK/APaetT/BH9j/AAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<matplotlib.figure.Figure at 0x11ffa3a50>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# load and display keypoints annotations\n",
+    "plt.imshow(I); plt.axis('off')\n",
+    "ax = plt.gca()\n",
+    "annIds = coco_kps.getAnnIds(imgIds=img['id'], catIds=catIds, iscrowd=None)\n",
+    "anns = coco_kps.loadAnns(annIds)\n",
+    "coco_kps.showAnns(anns)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "loading annotations into memory...\n",
+      "Done (t=0.13s)\n",
+      "creating index...\n",
+      "index created!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# initialize COCO api for caption annotations\n",
+    "annFile = '{}/annotations/captions_{}.json'.format(dataDir,dataType)\n",
+    "coco_caps=COCO(annFile)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "A man is skate boarding down a path and a dog is running by his side.\n",
+      "A man on a skateboard with a dog outside. \n",
+      "A person riding a skate board with a dog following beside.\n",
+      "This man is riding a skateboard behind a dog.\n",
+      "A man walking his dog on a quiet country road.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfAAAAFNCAYAAAD/+D1NAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSUVORK5CYII=\n",
+      "text/plain": [
+       "<matplotlib.figure.Figure at 0x11fd78190>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# load and display caption annotations\n",
+    "annIds = coco_caps.getAnnIds(imgIds=img['id']);\n",
+    "anns = coco_caps.loadAnns(annIds)\n",
+    "coco_caps.showAnns(anns)\n",
+    "plt.imshow(I); plt.axis('off'); plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 2",
+   "language": "python",
+   "name": "python2"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/pycocoEvalDemo.ipynb b/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/pycocoEvalDemo.ipynb
new file mode 100755
index 0000000..8b2ff08
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/pycocoEvalDemo.ipynb
@@ -0,0 +1,168 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "import matplotlib.pyplot as plt\n",
+    "from pycocotools.coco import COCO\n",
+    "from pycocotools.cocoeval import COCOeval\n",
+    "import numpy as np\n",
+    "import skimage.io as io\n",
+    "import pylab\n",
+    "pylab.rcParams['figure.figsize'] = (10.0, 8.0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running demo for *bbox* results.\n"
+     ]
+    }
+   ],
+   "source": [
+    "annType = ['segm','bbox','keypoints']\n",
+    "annType = annType[1]      #specify type here\n",
+    "prefix = 'person_keypoints' if annType=='keypoints' else 'instances'\n",
+    "print 'Running demo for *%s* results.'%(annType)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "loading annotations into memory...\n",
+      "Done (t=8.01s)\n",
+      "creating index...\n",
+      "index created!\n"
+     ]
+    }
+   ],
+   "source": [
+    "#initialize COCO ground truth api\n",
+    "dataDir='../'\n",
+    "dataType='val2014'\n",
+    "annFile = '%s/annotations/%s_%s.json'%(dataDir,prefix,dataType)\n",
+    "cocoGt=COCO(annFile)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading and preparing results...     \n",
+      "DONE (t=0.05s)\n",
+      "creating index...\n",
+      "index created!\n"
+     ]
+    }
+   ],
+   "source": [
+    "#initialize COCO detections api\n",
+    "resFile='%s/results/%s_%s_fake%s100_results.json'\n",
+    "resFile = resFile%(dataDir, prefix, dataType, annType)\n",
+    "cocoDt=cocoGt.loadRes(resFile)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "imgIds=sorted(cocoGt.getImgIds())\n",
+    "imgIds=imgIds[0:100]\n",
+    "imgId = imgIds[np.random.randint(100)]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running per image evaluation...      \n",
+      "DONE (t=0.46s).\n",
+      "Accumulating evaluation results...   \n",
+      "DONE (t=0.38s).\n",
+      " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.505\n",
+      " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.697\n",
+      " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.573\n",
+      " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.586\n",
+      " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.519\n",
+      " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.501\n",
+      " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.387\n",
+      " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.594\n",
+      " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.595\n",
+      " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.640\n",
+      " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.566\n",
+      " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.564\n"
+     ]
+    }
+   ],
+   "source": [
+    "# running evaluation\n",
+    "cocoEval = COCOeval(cocoGt,cocoDt,annType)\n",
+    "cocoEval.params.imgIds  = imgIds\n",
+    "cocoEval.evaluate()\n",
+    "cocoEval.accumulate()\n",
+    "cocoEval.summarize()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 2",
+   "language": "python",
+   "name": "python2"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/pycocotools/__init__.py b/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/pycocotools/__init__.py
new file mode 100755
index 0000000..3f7d85b
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/pycocotools/__init__.py
@@ -0,0 +1 @@
+__author__ = 'tylin'
diff --git a/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/pycocotools/_mask.c b/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/pycocotools/_mask.c
new file mode 100755
index 0000000..e0fc353
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/pycocotools/_mask.c
@@ -0,0 +1,16137 @@
+/* Generated by Cython 0.25.2 */
+
+#define PY_SSIZE_T_CLEAN
+#include "Python.h"
+#ifndef Py_PYTHON_H
+    #error Python headers needed to compile C extensions, please install development version of Python.
+#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000)
+    #error Cython requires Python 2.6+ or Python 3.2+.
+#else
+#define CYTHON_ABI "0_25_2"
+#include <stddef.h>
+#ifndef offsetof
+  #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
+#endif
+#if !defined(WIN32) && !defined(MS_WINDOWS)
+  #ifndef __stdcall
+    #define __stdcall
+  #endif
+  #ifndef __cdecl
+    #define __cdecl
+  #endif
+  #ifndef __fastcall
+    #define __fastcall
+  #endif
+#endif
+#ifndef DL_IMPORT
+  #define DL_IMPORT(t) t
+#endif
+#ifndef DL_EXPORT
+  #define DL_EXPORT(t) t
+#endif
+#ifndef HAVE_LONG_LONG
+  #if PY_VERSION_HEX >= 0x03030000 || (PY_MAJOR_VERSION == 2 && PY_VERSION_HEX >= 0x02070000)
+    #define HAVE_LONG_LONG
+  #endif
+#endif
+#ifndef PY_LONG_LONG
+  #define PY_LONG_LONG LONG_LONG
+#endif
+#ifndef Py_HUGE_VAL
+  #define Py_HUGE_VAL HUGE_VAL
+#endif
+#ifdef PYPY_VERSION
+  #define CYTHON_COMPILING_IN_PYPY 1
+  #define CYTHON_COMPILING_IN_PYSTON 0
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_ASYNC_SLOTS
+  #define CYTHON_USE_ASYNC_SLOTS 0
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #undef CYTHON_AVOID_BORROWED_REFS
+  #define CYTHON_AVOID_BORROWED_REFS 1
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+#elif defined(PYSTON_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_PYSTON 1
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #ifndef CYTHON_USE_TYPE_SLOTS
+    #define CYTHON_USE_TYPE_SLOTS 1
+  #endif
+  #undef CYTHON_USE_ASYNC_SLOTS
+  #define CYTHON_USE_ASYNC_SLOTS 0
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #ifndef CYTHON_USE_UNICODE_INTERNALS
+    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #endif
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #ifndef CYTHON_AVOID_BORROWED_REFS
+    #define CYTHON_AVOID_BORROWED_REFS 0
+  #endif
+  #ifndef CYTHON_ASSUME_SAFE_MACROS
+    #define CYTHON_ASSUME_SAFE_MACROS 1
+  #endif
+  #ifndef CYTHON_UNPACK_METHODS
+    #define CYTHON_UNPACK_METHODS 1
+  #endif
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+#else
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_PYSTON 0
+  #define CYTHON_COMPILING_IN_CPYTHON 1
+  #ifndef CYTHON_USE_TYPE_SLOTS
+    #define CYTHON_USE_TYPE_SLOTS 1
+  #endif
+  #if PY_MAJOR_VERSION < 3
+    #undef CYTHON_USE_ASYNC_SLOTS
+    #define CYTHON_USE_ASYNC_SLOTS 0
+  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+    #define CYTHON_USE_ASYNC_SLOTS 1
+  #endif
+  #if PY_VERSION_HEX < 0x02070000
+    #undef CYTHON_USE_PYLONG_INTERNALS
+    #define CYTHON_USE_PYLONG_INTERNALS 0
+  #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
+    #define CYTHON_USE_PYLONG_INTERNALS 1
+  #endif
+  #ifndef CYTHON_USE_PYLIST_INTERNALS
+    #define CYTHON_USE_PYLIST_INTERNALS 1
+  #endif
+  #ifndef CYTHON_USE_UNICODE_INTERNALS
+    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #endif
+  #if PY_VERSION_HEX < 0x030300F0
+    #undef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
+  #elif !defined(CYTHON_USE_UNICODE_WRITER)
+    #define CYTHON_USE_UNICODE_WRITER 1
+  #endif
+  #ifndef CYTHON_AVOID_BORROWED_REFS
+    #define CYTHON_AVOID_BORROWED_REFS 0
+  #endif
+  #ifndef CYTHON_ASSUME_SAFE_MACROS
+    #define CYTHON_ASSUME_SAFE_MACROS 1
+  #endif
+  #ifndef CYTHON_UNPACK_METHODS
+    #define CYTHON_UNPACK_METHODS 1
+  #endif
+  #ifndef CYTHON_FAST_THREAD_STATE
+    #define CYTHON_FAST_THREAD_STATE 1
+  #endif
+  #ifndef CYTHON_FAST_PYCALL
+    #define CYTHON_FAST_PYCALL 1
+  #endif
+#endif
+#if !defined(CYTHON_FAST_PYCCALL)
+#define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
+#endif
+#if CYTHON_USE_PYLONG_INTERNALS
+  #include "longintrepr.h"
+  #undef SHIFT
+  #undef BASE
+  #undef MASK
+#endif
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
+  #define Py_OptimizeFlag 0
+#endif
+#define __PYX_BUILD_PY_SSIZE_T "n"
+#define CYTHON_FORMAT_SSIZE_T "z"
+#if PY_MAJOR_VERSION < 3
+  #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
+  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+  #define __Pyx_DefaultClassType PyClass_Type
+#else
+  #define __Pyx_BUILTIN_MODULE_NAME "builtins"
+  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+  #define __Pyx_DefaultClassType PyType_Type
+#endif
+#ifndef Py_TPFLAGS_CHECKTYPES
+  #define Py_TPFLAGS_CHECKTYPES 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_INDEX
+  #define Py_TPFLAGS_HAVE_INDEX 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
+  #define Py_TPFLAGS_HAVE_NEWBUFFER 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_FINALIZE
+  #define Py_TPFLAGS_HAVE_FINALIZE 0
+#endif
+#ifndef METH_FASTCALL
+  #define METH_FASTCALL 0x80
+  typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject **args,
+                                              Py_ssize_t nargs, PyObject *kwnames);
+#else
+  #define __Pyx_PyCFunctionFast _PyCFunctionFast
+#endif
+#if CYTHON_FAST_PYCCALL
+#define __Pyx_PyFastCFunction_Check(func)\
+    ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST)))))
+#else
+#define __Pyx_PyFastCFunction_Check(func) 0
+#endif
+#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+  #define CYTHON_PEP393_ENABLED 1
+  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
+                                              0 : _PyUnicode_Ready((PyObject *)(op)))
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
+  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
+  #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
+  #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, ch)
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+#else
+  #define CYTHON_PEP393_ENABLED 0
+  #define PyUnicode_1BYTE_KIND  1
+  #define PyUnicode_2BYTE_KIND  2
+  #define PyUnicode_4BYTE_KIND  4
+  #define __Pyx_PyUnicode_READY(op)       (0)
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
+  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
+  #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
+  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
+#endif
+#if CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyUnicode_Concat(a, b)      PyNumber_Add(a, b)
+  #define __Pyx_PyUnicode_ConcatSafe(a, b)  PyNumber_Add(a, b)
+#else
+  #define __Pyx_PyUnicode_Concat(a, b)      PyUnicode_Concat(a, b)
+  #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
+      PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
+  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
+  #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
+  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
+  #define PyObject_Malloc(s)   PyMem_Malloc(s)
+  #define PyObject_Free(p)     PyMem_Free(p)
+  #define PyObject_Realloc(p)  PyMem_Realloc(p)
+#endif
+#if CYTHON_COMPILING_IN_PYSTON
+  #define __Pyx_PyCode_HasFreeVars(co)  PyCode_HasFreeVars(co)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
+#else
+  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
+#endif
+#define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
+#define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyString_Format(a, b)  PyUnicode_Format(a, b)
+#else
+  #define __Pyx_PyString_Format(a, b)  PyString_Format(a, b)
+#endif
+#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)
+  #define PyObject_ASCII(o)            PyObject_Repr(o)
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define PyBaseString_Type            PyUnicode_Type
+  #define PyStringObject               PyUnicodeObject
+  #define PyString_Type                PyUnicode_Type
+  #define PyString_Check               PyUnicode_Check
+  #define PyString_CheckExact          PyUnicode_CheckExact
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)
+  #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)
+#else
+  #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
+  #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
+#endif
+#ifndef PySet_CheckExact
+  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
+#endif
+#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
+#if PY_MAJOR_VERSION >= 3
+  #define PyIntObject                  PyLongObject
+  #define PyInt_Type                   PyLong_Type
+  #define PyInt_Check(op)              PyLong_Check(op)
+  #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
+  #define PyInt_FromString             PyLong_FromString
+  #define PyInt_FromUnicode            PyLong_FromUnicode
+  #define PyInt_FromLong               PyLong_FromLong
+  #define PyInt_FromSize_t             PyLong_FromSize_t
+  #define PyInt_FromSsize_t            PyLong_FromSsize_t
+  #define PyInt_AsLong                 PyLong_AsLong
+  #define PyInt_AS_LONG                PyLong_AS_LONG
+  #define PyInt_AsSsize_t              PyLong_AsSsize_t
+  #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
+  #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
+  #define PyNumber_Int                 PyNumber_Long
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define PyBoolObject                 PyLongObject
+#endif
+#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY
+  #ifndef PyUnicode_InternFromString
+    #define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
+  #endif
+#endif
+#if PY_VERSION_HEX < 0x030200A4
+  typedef long Py_hash_t;
+  #define __Pyx_PyInt_FromHash_t PyInt_FromLong
+  #define __Pyx_PyInt_AsHash_t   PyInt_AsLong
+#else
+  #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
+  #define __Pyx_PyInt_AsHash_t   PyInt_AsSsize_t
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func))
+#else
+  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
+#endif
+#if CYTHON_USE_ASYNC_SLOTS
+  #if PY_VERSION_HEX >= 0x030500B1
+    #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
+    #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async)
+  #else
+    typedef struct {
+        unaryfunc am_await;
+        unaryfunc am_aiter;
+        unaryfunc am_anext;
+    } __Pyx_PyAsyncMethodsStruct;
+    #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))
+  #endif
+#else
+  #define __Pyx_PyType_AsAsync(obj) NULL
+#endif
+#ifndef CYTHON_RESTRICT
+  #if defined(__GNUC__)
+    #define CYTHON_RESTRICT __restrict__
+  #elif defined(_MSC_VER) && _MSC_VER >= 1400
+    #define CYTHON_RESTRICT __restrict
+  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define CYTHON_RESTRICT restrict
+  #else
+    #define CYTHON_RESTRICT
+  #endif
+#endif
+#ifndef CYTHON_UNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define CYTHON_UNUSED __attribute__ ((__unused__))
+#   else
+#     define CYTHON_UNUSED
+#   endif
+# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))
+#   define CYTHON_UNUSED __attribute__ ((__unused__))
+# else
+#   define CYTHON_UNUSED
+# endif
+#endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+#  if defined(__cplusplus)
+     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+#  else
+#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+#  endif
+#endif
+#ifndef CYTHON_NCP_UNUSED
+# if CYTHON_COMPILING_IN_CPYTHON
+#  define CYTHON_NCP_UNUSED
+# else
+#  define CYTHON_NCP_UNUSED CYTHON_UNUSED
+# endif
+#endif
+#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
+
+#ifndef CYTHON_INLINE
+  #if defined(__clang__)
+    #define CYTHON_INLINE __inline__ __attribute__ ((__unused__))
+  #elif defined(__GNUC__)
+    #define CYTHON_INLINE __inline__
+  #elif defined(_MSC_VER)
+    #define CYTHON_INLINE __inline
+  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define CYTHON_INLINE inline
+  #else
+    #define CYTHON_INLINE
+  #endif
+#endif
+
+#if defined(WIN32) || defined(MS_WINDOWS)
+  #define _USE_MATH_DEFINES
+#endif
+#include <math.h>
+#ifdef NAN
+#define __PYX_NAN() ((float) NAN)
+#else
+static CYTHON_INLINE float __PYX_NAN() {
+  float value;
+  memset(&value, 0xFF, sizeof(value));
+  return value;
+}
+#endif
+#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL)
+#define __Pyx_truncl trunc
+#else
+#define __Pyx_truncl truncl
+#endif
+
+
+#define __PYX_ERR(f_index, lineno, Ln_error) \
+{ \
+  __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \
+}
+
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_TrueDivide(x,y)
+  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceTrueDivide(x,y)
+#else
+  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
+  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
+#endif
+
+#ifndef __PYX_EXTERN_C
+  #ifdef __cplusplus
+    #define __PYX_EXTERN_C extern "C"
+  #else
+    #define __PYX_EXTERN_C extern
+  #endif
+#endif
+
+#define __PYX_HAVE__pycocotools___mask
+#define __PYX_HAVE_API__pycocotools___mask
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "numpy/arrayobject.h"
+#include "numpy/ufuncobject.h"
+#include "maskApi.h"
+#ifdef _OPENMP
+#include <omp.h>
+#endif /* _OPENMP */
+
+#ifdef PYREX_WITHOUT_ASSERTIONS
+#define CYTHON_WITHOUT_ASSERTIONS
+#endif
+
+typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding;
+                const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;
+
+#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0
+#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0
+#define __PYX_DEFAULT_STRING_ENCODING ""
+#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString
+#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
+#define __Pyx_uchar_cast(c) ((unsigned char)c)
+#define __Pyx_long_cast(x) ((long)x)
+#define __Pyx_fits_Py_ssize_t(v, type, is_signed)  (\
+    (sizeof(type) < sizeof(Py_ssize_t))  ||\
+    (sizeof(type) > sizeof(Py_ssize_t) &&\
+          likely(v < (type)PY_SSIZE_T_MAX ||\
+                 v == (type)PY_SSIZE_T_MAX)  &&\
+          (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\
+                                v == (type)PY_SSIZE_T_MIN)))  ||\
+    (sizeof(type) == sizeof(Py_ssize_t) &&\
+          (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\
+                               v == (type)PY_SSIZE_T_MAX)))  )
+#if defined (__cplusplus) && __cplusplus >= 201103L
+    #include <cstdlib>
+    #define __Pyx_sst_abs(value) std::abs(value)
+#elif SIZEOF_INT >= SIZEOF_SIZE_T
+    #define __Pyx_sst_abs(value) abs(value)
+#elif SIZEOF_LONG >= SIZEOF_SIZE_T
+    #define __Pyx_sst_abs(value) labs(value)
+#elif defined (_MSC_VER) && defined (_M_X64)
+    #define __Pyx_sst_abs(value) _abs64(value)
+#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define __Pyx_sst_abs(value) llabs(value)
+#elif defined (__GNUC__)
+    #define __Pyx_sst_abs(value) __builtin_llabs(value)
+#else
+    #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
+#endif
+static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*);
+static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
+#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
+#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
+#define __Pyx_PyBytes_FromString        PyBytes_FromString
+#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
+#if PY_MAJOR_VERSION < 3
+    #define __Pyx_PyStr_FromString        __Pyx_PyBytes_FromString
+    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
+#else
+    #define __Pyx_PyStr_FromString        __Pyx_PyUnicode_FromString
+    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize
+#endif
+#define __Pyx_PyObject_AsSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
+#define __Pyx_PyBytes_FromCString(s)   __Pyx_PyBytes_FromString((const char*)s)
+#define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
+#define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
+#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
+#if PY_MAJOR_VERSION < 3
+static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u)
+{
+    const Py_UNICODE *u_end = u;
+    while (*u_end++) ;
+    return (size_t)(u_end - u - 1);
+}
+#else
+#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen
+#endif
+#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
+#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
+#define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
+#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
+#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
+#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False))
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
+#if CYTHON_ASSUME_SAFE_MACROS
+#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
+#else
+#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
+#endif
+#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))
+#if PY_MAJOR_VERSION >= 3
+#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))
+#else
+#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
+#endif
+#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+static int __Pyx_sys_getdefaultencoding_not_ascii;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+    PyObject* sys;
+    PyObject* default_encoding = NULL;
+    PyObject* ascii_chars_u = NULL;
+    PyObject* ascii_chars_b = NULL;
+    const char* default_encoding_c;
+    sys = PyImport_ImportModule("sys");
+    if (!sys) goto bad;
+    default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL);
+    Py_DECREF(sys);
+    if (!default_encoding) goto bad;
+    default_encoding_c = PyBytes_AsString(default_encoding);
+    if (!default_encoding_c) goto bad;
+    if (strcmp(default_encoding_c, "ascii") == 0) {
+        __Pyx_sys_getdefaultencoding_not_ascii = 0;
+    } else {
+        char ascii_chars[128];
+        int c;
+        for (c = 0; c < 128; c++) {
+            ascii_chars[c] = c;
+        }
+        __Pyx_sys_getdefaultencoding_not_ascii = 1;
+        ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
+        if (!ascii_chars_u) goto bad;
+        ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);
+        if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) {
+            PyErr_Format(
+                PyExc_ValueError,
+                "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.",
+                default_encoding_c);
+            goto bad;
+        }
+        Py_DECREF(ascii_chars_u);
+        Py_DECREF(ascii_chars_b);
+    }
+    Py_DECREF(default_encoding);
+    return 0;
+bad:
+    Py_XDECREF(default_encoding);
+    Py_XDECREF(ascii_chars_u);
+    Py_XDECREF(ascii_chars_b);
+    return -1;
+}
+#endif
+#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3
+#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
+#else
+#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
+#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+static char* __PYX_DEFAULT_STRING_ENCODING;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+    PyObject* sys;
+    PyObject* default_encoding = NULL;
+    char* default_encoding_c;
+    sys = PyImport_ImportModule("sys");
+    if (!sys) goto bad;
+    default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL);
+    Py_DECREF(sys);
+    if (!default_encoding) goto bad;
+    default_encoding_c = PyBytes_AsString(default_encoding);
+    if (!default_encoding_c) goto bad;
+    __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c));
+    if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;
+    strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);
+    Py_DECREF(default_encoding);
+    return 0;
+bad:
+    Py_XDECREF(default_encoding);
+    return -1;
+}
+#endif
+#endif
+
+
+/* Test for GCC > 2.95 */
+#if defined(__GNUC__)     && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
+  #define likely(x)   __builtin_expect(!!(x), 1)
+  #define unlikely(x) __builtin_expect(!!(x), 0)
+#else /* !__GNUC__ or GCC < 2.95 */
+  #define likely(x)   (x)
+  #define unlikely(x) (x)
+#endif /* __GNUC__ */
+
+static PyObject *__pyx_m;
+static PyObject *__pyx_d;
+static PyObject *__pyx_b;
+static PyObject *__pyx_empty_tuple;
+static PyObject *__pyx_empty_bytes;
+static PyObject *__pyx_empty_unicode;
+static int __pyx_lineno;
+static int __pyx_clineno = 0;
+static const char * __pyx_cfilenm= __FILE__;
+static const char *__pyx_filename;
+
+/* Header.proto */
+#if !defined(CYTHON_CCOMPLEX)
+  #if defined(__cplusplus)
+    #define CYTHON_CCOMPLEX 1
+  #elif defined(_Complex_I)
+    #define CYTHON_CCOMPLEX 1
+  #else
+    #define CYTHON_CCOMPLEX 0
+  #endif
+#endif
+#if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    #include <complex>
+  #else
+    #include <complex.h>
+  #endif
+#endif
+#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__)
+  #undef _Complex_I
+  #define _Complex_I 1.0fj
+#endif
+
+
+static const char *__pyx_f[] = {
+  "pycocotools/_mask.pyx",
+  "__init__.pxd",
+  "type.pxd",
+};
+/* BufferFormatStructs.proto */
+#define IS_UNSIGNED(type) (((type) -1) > 0)
+struct __Pyx_StructField_;
+#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0)
+typedef struct {
+  const char* name;
+  struct __Pyx_StructField_* fields;
+  size_t size;
+  size_t arraysize[8];
+  int ndim;
+  char typegroup;
+  char is_unsigned;
+  int flags;
+} __Pyx_TypeInfo;
+typedef struct __Pyx_StructField_ {
+  __Pyx_TypeInfo* type;
+  const char* name;
+  size_t offset;
+} __Pyx_StructField;
+typedef struct {
+  __Pyx_StructField* field;
+  size_t parent_offset;
+} __Pyx_BufFmt_StackElem;
+typedef struct {
+  __Pyx_StructField root;
+  __Pyx_BufFmt_StackElem* head;
+  size_t fmt_offset;
+  size_t new_count, enc_count;
+  size_t struct_alignment;
+  int is_complex;
+  char enc_type;
+  char new_packmode;
+  char enc_packmode;
+  char is_valid_array;
+} __Pyx_BufFmt_Context;
+
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":725
+ * # in Cython to enable them only on the right systems.
+ * 
+ * ctypedef npy_int8       int8_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_int16      int16_t
+ * ctypedef npy_int32      int32_t
+ */
+typedef npy_int8 __pyx_t_5numpy_int8_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":726
+ * 
+ * ctypedef npy_int8       int8_t
+ * ctypedef npy_int16      int16_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_int32      int32_t
+ * ctypedef npy_int64      int64_t
+ */
+typedef npy_int16 __pyx_t_5numpy_int16_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":727
+ * ctypedef npy_int8       int8_t
+ * ctypedef npy_int16      int16_t
+ * ctypedef npy_int32      int32_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_int64      int64_t
+ * #ctypedef npy_int96      int96_t
+ */
+typedef npy_int32 __pyx_t_5numpy_int32_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":728
+ * ctypedef npy_int16      int16_t
+ * ctypedef npy_int32      int32_t
+ * ctypedef npy_int64      int64_t             # <<<<<<<<<<<<<<
+ * #ctypedef npy_int96      int96_t
+ * #ctypedef npy_int128     int128_t
+ */
+typedef npy_int64 __pyx_t_5numpy_int64_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":732
+ * #ctypedef npy_int128     int128_t
+ * 
+ * ctypedef npy_uint8      uint8_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_uint16     uint16_t
+ * ctypedef npy_uint32     uint32_t
+ */
+typedef npy_uint8 __pyx_t_5numpy_uint8_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":733
+ * 
+ * ctypedef npy_uint8      uint8_t
+ * ctypedef npy_uint16     uint16_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_uint32     uint32_t
+ * ctypedef npy_uint64     uint64_t
+ */
+typedef npy_uint16 __pyx_t_5numpy_uint16_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":734
+ * ctypedef npy_uint8      uint8_t
+ * ctypedef npy_uint16     uint16_t
+ * ctypedef npy_uint32     uint32_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_uint64     uint64_t
+ * #ctypedef npy_uint96     uint96_t
+ */
+typedef npy_uint32 __pyx_t_5numpy_uint32_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":735
+ * ctypedef npy_uint16     uint16_t
+ * ctypedef npy_uint32     uint32_t
+ * ctypedef npy_uint64     uint64_t             # <<<<<<<<<<<<<<
+ * #ctypedef npy_uint96     uint96_t
+ * #ctypedef npy_uint128    uint128_t
+ */
+typedef npy_uint64 __pyx_t_5numpy_uint64_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":739
+ * #ctypedef npy_uint128    uint128_t
+ * 
+ * ctypedef npy_float32    float32_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_float64    float64_t
+ * #ctypedef npy_float80    float80_t
+ */
+typedef npy_float32 __pyx_t_5numpy_float32_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":740
+ * 
+ * ctypedef npy_float32    float32_t
+ * ctypedef npy_float64    float64_t             # <<<<<<<<<<<<<<
+ * #ctypedef npy_float80    float80_t
+ * #ctypedef npy_float128   float128_t
+ */
+typedef npy_float64 __pyx_t_5numpy_float64_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":749
+ * # The int types are mapped a bit surprising --
+ * # numpy.int corresponds to 'l' and numpy.long to 'q'
+ * ctypedef npy_long       int_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_longlong   long_t
+ * ctypedef npy_longlong   longlong_t
+ */
+typedef npy_long __pyx_t_5numpy_int_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":750
+ * # numpy.int corresponds to 'l' and numpy.long to 'q'
+ * ctypedef npy_long       int_t
+ * ctypedef npy_longlong   long_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_longlong   longlong_t
+ * 
+ */
+typedef npy_longlong __pyx_t_5numpy_long_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":751
+ * ctypedef npy_long       int_t
+ * ctypedef npy_longlong   long_t
+ * ctypedef npy_longlong   longlong_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_ulong      uint_t
+ */
+typedef npy_longlong __pyx_t_5numpy_longlong_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":753
+ * ctypedef npy_longlong   longlong_t
+ * 
+ * ctypedef npy_ulong      uint_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_ulonglong  ulong_t
+ * ctypedef npy_ulonglong  ulonglong_t
+ */
+typedef npy_ulong __pyx_t_5numpy_uint_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":754
+ * 
+ * ctypedef npy_ulong      uint_t
+ * ctypedef npy_ulonglong  ulong_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_ulonglong  ulonglong_t
+ * 
+ */
+typedef npy_ulonglong __pyx_t_5numpy_ulong_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":755
+ * ctypedef npy_ulong      uint_t
+ * ctypedef npy_ulonglong  ulong_t
+ * ctypedef npy_ulonglong  ulonglong_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_intp       intp_t
+ */
+typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":757
+ * ctypedef npy_ulonglong  ulonglong_t
+ * 
+ * ctypedef npy_intp       intp_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_uintp      uintp_t
+ * 
+ */
+typedef npy_intp __pyx_t_5numpy_intp_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":758
+ * 
+ * ctypedef npy_intp       intp_t
+ * ctypedef npy_uintp      uintp_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_double     float_t
+ */
+typedef npy_uintp __pyx_t_5numpy_uintp_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":760
+ * ctypedef npy_uintp      uintp_t
+ * 
+ * ctypedef npy_double     float_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_double     double_t
+ * ctypedef npy_longdouble longdouble_t
+ */
+typedef npy_double __pyx_t_5numpy_float_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":761
+ * 
+ * ctypedef npy_double     float_t
+ * ctypedef npy_double     double_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_longdouble longdouble_t
+ * 
+ */
+typedef npy_double __pyx_t_5numpy_double_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":762
+ * ctypedef npy_double     float_t
+ * ctypedef npy_double     double_t
+ * ctypedef npy_longdouble longdouble_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_cfloat      cfloat_t
+ */
+typedef npy_longdouble __pyx_t_5numpy_longdouble_t;
+/* Declarations.proto */
+#if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    typedef ::std::complex< float > __pyx_t_float_complex;
+  #else
+    typedef float _Complex __pyx_t_float_complex;
+  #endif
+#else
+    typedef struct { float real, imag; } __pyx_t_float_complex;
+#endif
+static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float);
+
+/* Declarations.proto */
+#if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    typedef ::std::complex< double > __pyx_t_double_complex;
+  #else
+    typedef double _Complex __pyx_t_double_complex;
+  #endif
+#else
+    typedef struct { double real, imag; } __pyx_t_double_complex;
+#endif
+static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double);
+
+
+/*--- Type declarations ---*/
+struct __pyx_obj_11pycocotools_5_mask_RLEs;
+struct __pyx_obj_11pycocotools_5_mask_Masks;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":764
+ * ctypedef npy_longdouble longdouble_t
+ * 
+ * ctypedef npy_cfloat      cfloat_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_cdouble     cdouble_t
+ * ctypedef npy_clongdouble clongdouble_t
+ */
+typedef npy_cfloat __pyx_t_5numpy_cfloat_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":765
+ * 
+ * ctypedef npy_cfloat      cfloat_t
+ * ctypedef npy_cdouble     cdouble_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_clongdouble clongdouble_t
+ * 
+ */
+typedef npy_cdouble __pyx_t_5numpy_cdouble_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":766
+ * ctypedef npy_cfloat      cfloat_t
+ * ctypedef npy_cdouble     cdouble_t
+ * ctypedef npy_clongdouble clongdouble_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_cdouble     complex_t
+ */
+typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":768
+ * ctypedef npy_clongdouble clongdouble_t
+ * 
+ * ctypedef npy_cdouble     complex_t             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew1(a):
+ */
+typedef npy_cdouble __pyx_t_5numpy_complex_t;
+
+/* "pycocotools/_mask.pyx":56
+ * # python class to wrap RLE array in C
+ * # the class handles the memory allocation and deallocation
+ * cdef class RLEs:             # <<<<<<<<<<<<<<
+ *     cdef RLE *_R
+ *     cdef siz _n
+ */
+struct __pyx_obj_11pycocotools_5_mask_RLEs {
+  PyObject_HEAD
+  RLE *_R;
+  siz _n;
+};
+
+
+/* "pycocotools/_mask.pyx":77
+ * # python class to wrap Mask array in C
+ * # the class handles the memory allocation and deallocation
+ * cdef class Masks:             # <<<<<<<<<<<<<<
+ *     cdef byte *_mask
+ *     cdef siz _h
+ */
+struct __pyx_obj_11pycocotools_5_mask_Masks {
+  PyObject_HEAD
+  byte *_mask;
+  siz _h;
+  siz _w;
+  siz _n;
+};
+
+
+/* --- Runtime support code (head) --- */
+/* Refnanny.proto */
+#ifndef CYTHON_REFNANNY
+  #define CYTHON_REFNANNY 0
+#endif
+#if CYTHON_REFNANNY
+  typedef struct {
+    void (*INCREF)(void*, PyObject*, int);
+    void (*DECREF)(void*, PyObject*, int);
+    void (*GOTREF)(void*, PyObject*, int);
+    void (*GIVEREF)(void*, PyObject*, int);
+    void* (*SetupContext)(const char*, int, const char*);
+    void (*FinishContext)(void**);
+  } __Pyx_RefNannyAPIStruct;
+  static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
+  static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);
+  #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;
+#ifdef WITH_THREAD
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
+          if (acquire_gil) {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              PyGILState_Release(__pyx_gilstate_save);\
+          } else {\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+          }
+#else
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
+          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+#endif
+  #define __Pyx_RefNannyFinishContext()\
+          __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
+  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
+  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
+  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
+  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
+#else
+  #define __Pyx_RefNannyDeclarations
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContext()
+  #define __Pyx_INCREF(r) Py_INCREF(r)
+  #define __Pyx_DECREF(r) Py_DECREF(r)
+  #define __Pyx_GOTREF(r)
+  #define __Pyx_GIVEREF(r)
+  #define __Pyx_XINCREF(r) Py_XINCREF(r)
+  #define __Pyx_XDECREF(r) Py_XDECREF(r)
+  #define __Pyx_XGOTREF(r)
+  #define __Pyx_XGIVEREF(r)
+#endif
+#define __Pyx_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; __Pyx_XDECREF(tmp);\
+    } while (0)
+#define __Pyx_DECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; __Pyx_DECREF(tmp);\
+    } while (0)
+#define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
+#define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
+
+/* PyObjectGetAttrStr.proto */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro))
+        return tp->tp_getattro(obj, attr_name);
+#if PY_MAJOR_VERSION < 3
+    if (likely(tp->tp_getattr))
+        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
+#endif
+    return PyObject_GetAttr(obj, attr_name);
+}
+#else
+#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
+#endif
+
+/* GetBuiltinName.proto */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name);
+
+/* RaiseDoubleKeywords.proto */
+static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
+
+/* ParseKeywords.proto */
+static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
+    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
+    const char* function_name);
+
+/* RaiseArgTupleInvalid.proto */
+static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
+    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
+
+/* IncludeStringH.proto */
+#include <string.h>
+
+/* BytesEquals.proto */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* UnicodeEquals.proto */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* StrEquals.proto */
+#if PY_MAJOR_VERSION >= 3
+#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals
+#else
+#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals
+#endif
+
+/* PyObjectCall.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
+#else
+#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
+#endif
+
+/* PyThreadStateGet.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
+#define __Pyx_PyThreadState_assign  __pyx_tstate = PyThreadState_GET();
+#else
+#define __Pyx_PyThreadState_declare
+#define __Pyx_PyThreadState_assign
+#endif
+
+/* PyErrFetchRestore.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#else
+#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
+#endif
+
+/* RaiseException.proto */
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
+
+/* ExtTypeTest.proto */
+static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type);
+
+/* ArgTypeTest.proto */
+static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,
+    const char *name, int exact);
+
+/* ListAppend.proto */
+#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
+static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
+    PyListObject* L = (PyListObject*) list;
+    Py_ssize_t len = Py_SIZE(list);
+    if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) {
+        Py_INCREF(x);
+        PyList_SET_ITEM(list, len, x);
+        Py_SIZE(list) = len+1;
+        return 0;
+    }
+    return PyList_Append(list, x);
+}
+#else
+#define __Pyx_PyList_Append(L,x) PyList_Append(L,x)
+#endif
+
+/* PyIntBinop.proto */
+#if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace);
+#else
+#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace)\
+    (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2))
+#endif
+
+/* PyIntBinop.proto */
+#if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, long intval, int inplace);
+#else
+#define __Pyx_PyInt_EqObjC(op1, op2, intval, inplace)\
+    PyObject_RichCompare(op1, op2, Py_EQ)
+    #endif
+
+/* GetModuleGlobalName.proto */
+static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name);
+
+/* PyCFunctionFastCall.proto */
+#if CYTHON_FAST_PYCCALL
+static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs);
+#else
+#define __Pyx_PyCFunction_FastCall(func, args, nargs)  (assert(0), NULL)
+#endif
+
+/* PyFunctionFastCall.proto */
+#if CYTHON_FAST_PYCALL
+#define __Pyx_PyFunction_FastCall(func, args, nargs)\
+    __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
+#if 1 || PY_VERSION_HEX < 0x030600B1
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs);
+#else
+#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs)
+#endif
+#endif
+
+/* PyObjectCallMethO.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
+#endif
+
+/* PyObjectCallOneArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+
+/* GetItemInt.proto */
+#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
+    __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\
+    (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\
+               __Pyx_GetItemInt_Generic(o, to_py_func(i))))
+#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
+    __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
+    (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL))
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
+                                                              int wraparound, int boundscheck);
+#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
+    __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
+    (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL))
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
+                                                              int wraparound, int boundscheck);
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j);
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
+                                                     int is_list, int wraparound, int boundscheck);
+
+/* BufferFormatCheck.proto */
+static CYTHON_INLINE int  __Pyx_GetBufferAndValidate(Py_buffer* buf, PyObject* obj,
+    __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack);
+static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info);
+static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts);
+static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,
+                              __Pyx_BufFmt_StackElem* stack,
+                              __Pyx_TypeInfo* type); // PROTO
+
+/* ListCompAppend.proto */
+#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
+static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
+    PyListObject* L = (PyListObject*) list;
+    Py_ssize_t len = Py_SIZE(list);
+    if (likely(L->allocated > len)) {
+        Py_INCREF(x);
+        PyList_SET_ITEM(list, len, x);
+        Py_SIZE(list) = len+1;
+        return 0;
+    }
+    return PyList_Append(list, x);
+}
+#else
+#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x)
+#endif
+
+/* FetchCommonType.proto */
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
+
+/* CythonFunction.proto */
+#define __Pyx_CyFunction_USED 1
+#include <structmember.h>
+#define __Pyx_CYFUNCTION_STATICMETHOD  0x01
+#define __Pyx_CYFUNCTION_CLASSMETHOD   0x02
+#define __Pyx_CYFUNCTION_CCLASS        0x04
+#define __Pyx_CyFunction_GetClosure(f)\
+    (((__pyx_CyFunctionObject *) (f))->func_closure)
+#define __Pyx_CyFunction_GetClassObj(f)\
+    (((__pyx_CyFunctionObject *) (f))->func_classobj)
+#define __Pyx_CyFunction_Defaults(type, f)\
+    ((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
+#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\
+    ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
+typedef struct {
+    PyCFunctionObject func;
+#if PY_VERSION_HEX < 0x030500A0
+    PyObject *func_weakreflist;
+#endif
+    PyObject *func_dict;
+    PyObject *func_name;
+    PyObject *func_qualname;
+    PyObject *func_doc;
+    PyObject *func_globals;
+    PyObject *func_code;
+    PyObject *func_closure;
+    PyObject *func_classobj;
+    void *defaults;
+    int defaults_pyobjects;
+    int flags;
+    PyObject *defaults_tuple;
+    PyObject *defaults_kwdict;
+    PyObject *(*defaults_getter)(PyObject *);
+    PyObject *func_annotations;
+} __pyx_CyFunctionObject;
+static PyTypeObject *__pyx_CyFunctionType = 0;
+#define __Pyx_CyFunction_NewEx(ml, flags, qualname, self, module, globals, code)\
+    __Pyx_CyFunction_New(__pyx_CyFunctionType, ml, flags, qualname, self, module, globals, code)
+static PyObject *__Pyx_CyFunction_New(PyTypeObject *, PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *self,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m,
+                                                         size_t size,
+                                                         int pyobjects);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m,
+                                                            PyObject *tuple);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m,
+                                                             PyObject *dict);
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
+                                                              PyObject *dict);
+static int __pyx_CyFunction_init(void);
+
+/* BufferFallbackError.proto */
+static void __Pyx_RaiseBufferFallbackError(void);
+
+/* None.proto */
+static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t, Py_ssize_t);
+
+/* BufferIndexError.proto */
+static void __Pyx_RaiseBufferIndexError(int axis);
+
+#define __Pyx_BufPtrStrided1d(type, buf, i0, s0) (type)((char*)buf + i0 * s0)
+/* PySequenceContains.proto */
+static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) {
+    int result = PySequence_Contains(seq, item);
+    return unlikely(result < 0) ? result : (result == (eq == Py_EQ));
+}
+
+/* DictGetItem.proto */
+#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
+static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
+    PyObject *value;
+    value = PyDict_GetItemWithError(d, key);
+    if (unlikely(!value)) {
+        if (!PyErr_Occurred()) {
+            PyObject* args = PyTuple_Pack(1, key);
+            if (likely(args))
+                PyErr_SetObject(PyExc_KeyError, args);
+            Py_XDECREF(args);
+        }
+        return NULL;
+    }
+    Py_INCREF(value);
+    return value;
+}
+#else
+    #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key)
+#endif
+
+/* RaiseTooManyValuesToUnpack.proto */
+static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);
+
+/* RaiseNeedMoreValuesToUnpack.proto */
+static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);
+
+/* RaiseNoneIterError.proto */
+static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);
+
+/* SaveResetException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_ExceptionSave(type, value, tb)  __Pyx__ExceptionSave(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#define __Pyx_ExceptionReset(type, value, tb)  __Pyx__ExceptionReset(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+#else
+#define __Pyx_ExceptionSave(type, value, tb)   PyErr_GetExcInfo(type, value, tb)
+#define __Pyx_ExceptionReset(type, value, tb)  PyErr_SetExcInfo(type, value, tb)
+#endif
+
+/* PyErrExceptionMatches.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
+#else
+#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
+#endif
+
+/* GetException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_GetException(type, value, tb)  __Pyx__GetException(__pyx_tstate, type, value, tb)
+static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#else
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb);
+#endif
+
+/* Import.proto */
+static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);
+
+/* CodeObjectCache.proto */
+typedef struct {
+    PyCodeObject* code_object;
+    int code_line;
+} __Pyx_CodeObjectCacheEntry;
+struct __Pyx_CodeObjectCache {
+    int count;
+    int max_count;
+    __Pyx_CodeObjectCacheEntry* entries;
+};
+static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
+static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
+static PyCodeObject *__pyx_find_code_object(int code_line);
+static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
+
+/* AddTraceback.proto */
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename);
+
+/* BufferStructDeclare.proto */
+typedef struct {
+  Py_ssize_t shape, strides, suboffsets;
+} __Pyx_Buf_DimInfo;
+typedef struct {
+  size_t refcount;
+  Py_buffer pybuffer;
+} __Pyx_Buffer;
+typedef struct {
+  __Pyx_Buffer *rcbuffer;
+  char *data;
+  __Pyx_Buf_DimInfo diminfo[8];
+} __Pyx_LocalBuf_ND;
+
+#if PY_MAJOR_VERSION < 3
+    static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags);
+    static void __Pyx_ReleaseBuffer(Py_buffer *view);
+#else
+    #define __Pyx_GetBuffer PyObject_GetBuffer
+    #define __Pyx_ReleaseBuffer PyBuffer_Release
+#endif
+
+
+/* None.proto */
+static Py_ssize_t __Pyx_zeros[] = {0, 0, 0, 0, 0, 0, 0, 0};
+static Py_ssize_t __Pyx_minusones[] = {-1, -1, -1, -1, -1, -1, -1, -1};
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_siz(siz value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_Py_intptr_t(Py_intptr_t value);
+
+/* RealImag.proto */
+#if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    #define __Pyx_CREAL(z) ((z).real())
+    #define __Pyx_CIMAG(z) ((z).imag())
+  #else
+    #define __Pyx_CREAL(z) (__real__(z))
+    #define __Pyx_CIMAG(z) (__imag__(z))
+  #endif
+#else
+    #define __Pyx_CREAL(z) ((z).real)
+    #define __Pyx_CIMAG(z) ((z).imag)
+#endif
+#if defined(__cplusplus) && CYTHON_CCOMPLEX\
+        && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103)
+    #define __Pyx_SET_CREAL(z,x) ((z).real(x))
+    #define __Pyx_SET_CIMAG(z,y) ((z).imag(y))
+#else
+    #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x)
+    #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y)
+#endif
+
+/* Arithmetic.proto */
+#if CYTHON_CCOMPLEX
+    #define __Pyx_c_eq_float(a, b)   ((a)==(b))
+    #define __Pyx_c_sum_float(a, b)  ((a)+(b))
+    #define __Pyx_c_diff_float(a, b) ((a)-(b))
+    #define __Pyx_c_prod_float(a, b) ((a)*(b))
+    #define __Pyx_c_quot_float(a, b) ((a)/(b))
+    #define __Pyx_c_neg_float(a)     (-(a))
+  #ifdef __cplusplus
+    #define __Pyx_c_is_zero_float(z) ((z)==(float)0)
+    #define __Pyx_c_conj_float(z)    (::std::conj(z))
+    #if 1
+        #define __Pyx_c_abs_float(z)     (::std::abs(z))
+        #define __Pyx_c_pow_float(a, b)  (::std::pow(a, b))
+    #endif
+  #else
+    #define __Pyx_c_is_zero_float(z) ((z)==0)
+    #define __Pyx_c_conj_float(z)    (conjf(z))
+    #if 1
+        #define __Pyx_c_abs_float(z)     (cabsf(z))
+        #define __Pyx_c_pow_float(a, b)  (cpowf(a, b))
+    #endif
+ #endif
+#else
+    static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex);
+    static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex);
+    #if 1
+        static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex);
+        static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    #endif
+#endif
+
+/* Arithmetic.proto */
+#if CYTHON_CCOMPLEX
+    #define __Pyx_c_eq_double(a, b)   ((a)==(b))
+    #define __Pyx_c_sum_double(a, b)  ((a)+(b))
+    #define __Pyx_c_diff_double(a, b) ((a)-(b))
+    #define __Pyx_c_prod_double(a, b) ((a)*(b))
+    #define __Pyx_c_quot_double(a, b) ((a)/(b))
+    #define __Pyx_c_neg_double(a)     (-(a))
+  #ifdef __cplusplus
+    #define __Pyx_c_is_zero_double(z) ((z)==(double)0)
+    #define __Pyx_c_conj_double(z)    (::std::conj(z))
+    #if 1
+        #define __Pyx_c_abs_double(z)     (::std::abs(z))
+        #define __Pyx_c_pow_double(a, b)  (::std::pow(a, b))
+    #endif
+  #else
+    #define __Pyx_c_is_zero_double(z) ((z)==0)
+    #define __Pyx_c_conj_double(z)    (conj(z))
+    #if 1
+        #define __Pyx_c_abs_double(z)     (cabs(z))
+        #define __Pyx_c_pow_double(a, b)  (cpow(a, b))
+    #endif
+ #endif
+#else
+    static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex);
+    static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex);
+    #if 1
+        static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex);
+        static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    #endif
+#endif
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE siz __Pyx_PyInt_As_siz(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
+
+/* CheckBinaryVersion.proto */
+static int __Pyx_check_binary_version(void);
+
+/* PyIdentifierFromString.proto */
+#if !defined(__Pyx_PyIdentifier_FromString)
+#if PY_MAJOR_VERSION < 3
+  #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s)
+#else
+  #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s)
+#endif
+#endif
+
+/* ModuleImport.proto */
+static PyObject *__Pyx_ImportModule(const char *name);
+
+/* TypeImport.proto */
+static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict);
+
+/* InitStrings.proto */
+static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
+
+
+/* Module declarations from 'cpython.buffer' */
+
+/* Module declarations from 'libc.string' */
+
+/* Module declarations from 'libc.stdio' */
+
+/* Module declarations from '__builtin__' */
+
+/* Module declarations from 'cpython.type' */
+static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0;
+
+/* Module declarations from 'cpython' */
+
+/* Module declarations from 'cpython.object' */
+
+/* Module declarations from 'cpython.ref' */
+
+/* Module declarations from 'libc.stdlib' */
+
+/* Module declarations from 'numpy' */
+
+/* Module declarations from 'numpy' */
+static PyTypeObject *__pyx_ptype_5numpy_dtype = 0;
+static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0;
+static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0;
+static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0;
+static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0;
+static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/
+static CYTHON_INLINE int __pyx_f_5numpy_import_array(void); /*proto*/
+
+/* Module declarations from 'pycocotools._mask' */
+static PyTypeObject *__pyx_ptype_11pycocotools_5_mask_RLEs = 0;
+static PyTypeObject *__pyx_ptype_11pycocotools_5_mask_Masks = 0;
+static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_uint8_t = { "uint8_t", NULL, sizeof(__pyx_t_5numpy_uint8_t), { 0 }, 0, IS_UNSIGNED(__pyx_t_5numpy_uint8_t) ? 'U' : 'I', IS_UNSIGNED(__pyx_t_5numpy_uint8_t), 0 };
+static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_double_t = { "double_t", NULL, sizeof(__pyx_t_5numpy_double_t), { 0 }, 0, 'R', 0, 0 };
+static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_uint32_t = { "uint32_t", NULL, sizeof(__pyx_t_5numpy_uint32_t), { 0 }, 0, IS_UNSIGNED(__pyx_t_5numpy_uint32_t) ? 'U' : 'I', IS_UNSIGNED(__pyx_t_5numpy_uint32_t), 0 };
+#define __Pyx_MODULE_NAME "pycocotools._mask"
+int __pyx_module_is_main_pycocotools___mask = 0;
+
+/* Implementation of 'pycocotools._mask' */
+static PyObject *__pyx_builtin_range;
+static PyObject *__pyx_builtin_AttributeError;
+static PyObject *__pyx_builtin_enumerate;
+static PyObject *__pyx_builtin_ValueError;
+static PyObject *__pyx_builtin_RuntimeError;
+static PyObject *__pyx_builtin_ImportError;
+static const char __pyx_k_F[] = "F";
+static const char __pyx_k_N[] = "N";
+static const char __pyx_k_R[] = "R";
+static const char __pyx_k_a[] = "_a";
+static const char __pyx_k_h[] = "h";
+static const char __pyx_k_i[] = "i";
+static const char __pyx_k_j[] = "j";
+static const char __pyx_k_m[] = "m";
+static const char __pyx_k_n[] = "n";
+static const char __pyx_k_p[] = "p";
+static const char __pyx_k_w[] = "w";
+static const char __pyx_k_Rs[] = "Rs";
+static const char __pyx_k_bb[] = "bb";
+static const char __pyx_k_dt[] = "dt";
+static const char __pyx_k_gt[] = "gt";
+static const char __pyx_k_np[] = "np";
+static const char __pyx_k_a_2[] = "a";
+static const char __pyx_k_all[] = "all";
+static const char __pyx_k_iou[] = "_iou";
+static const char __pyx_k_len[] = "_len";
+static const char __pyx_k_obj[] = "obj";
+static const char __pyx_k_sys[] = "sys";
+static const char __pyx_k_area[] = "area";
+static const char __pyx_k_bb_2[] = "_bb";
+static const char __pyx_k_cnts[] = "cnts";
+static const char __pyx_k_data[] = "data";
+static const char __pyx_k_main[] = "__main__";
+static const char __pyx_k_mask[] = "mask";
+static const char __pyx_k_objs[] = "objs";
+static const char __pyx_k_poly[] = "poly";
+static const char __pyx_k_size[] = "size";
+static const char __pyx_k_test[] = "__test__";
+static const char __pyx_k_utf8[] = "utf8";
+static const char __pyx_k_array[] = "array";
+static const char __pyx_k_bbIou[] = "_bbIou";
+static const char __pyx_k_dtype[] = "dtype";
+static const char __pyx_k_iou_2[] = "iou";
+static const char __pyx_k_isbox[] = "isbox";
+static const char __pyx_k_isrle[] = "isrle";
+static const char __pyx_k_masks[] = "masks";
+static const char __pyx_k_merge[] = "merge";
+static const char __pyx_k_numpy[] = "numpy";
+static const char __pyx_k_order[] = "order";
+static const char __pyx_k_pyobj[] = "pyobj";
+static const char __pyx_k_range[] = "range";
+static const char __pyx_k_shape[] = "shape";
+static const char __pyx_k_uint8[] = "uint8";
+static const char __pyx_k_zeros[] = "zeros";
+static const char __pyx_k_astype[] = "astype";
+static const char __pyx_k_author[] = "__author__";
+static const char __pyx_k_counts[] = "counts";
+static const char __pyx_k_decode[] = "decode";
+static const char __pyx_k_double[] = "double";
+static const char __pyx_k_encode[] = "encode";
+static const char __pyx_k_frBbox[] = "frBbox";
+static const char __pyx_k_frPoly[] = "frPoly";
+static const char __pyx_k_import[] = "__import__";
+static const char __pyx_k_iouFun[] = "_iouFun";
+static const char __pyx_k_rleIou[] = "_rleIou";
+static const char __pyx_k_toBbox[] = "toBbox";
+static const char __pyx_k_ucRles[] = "ucRles";
+static const char __pyx_k_uint32[] = "uint32";
+static const char __pyx_k_iscrowd[] = "iscrowd";
+static const char __pyx_k_np_poly[] = "np_poly";
+static const char __pyx_k_preproc[] = "_preproc";
+static const char __pyx_k_reshape[] = "reshape";
+static const char __pyx_k_rleObjs[] = "rleObjs";
+static const char __pyx_k_tsungyi[] = "tsungyi";
+static const char __pyx_k_c_string[] = "c_string";
+static const char __pyx_k_frString[] = "_frString";
+static const char __pyx_k_toString[] = "_toString";
+static const char __pyx_k_enumerate[] = "enumerate";
+static const char __pyx_k_intersect[] = "intersect";
+static const char __pyx_k_py_string[] = "py_string";
+static const char __pyx_k_pyiscrowd[] = "pyiscrowd";
+static const char __pyx_k_ValueError[] = "ValueError";
+static const char __pyx_k_ImportError[] = "ImportError";
+static const char __pyx_k_frPyObjects[] = "frPyObjects";
+static const char __pyx_k_RuntimeError[] = "RuntimeError";
+static const char __pyx_k_version_info[] = "version_info";
+static const char __pyx_k_AttributeError[] = "AttributeError";
+static const char __pyx_k_PYTHON_VERSION[] = "PYTHON_VERSION";
+static const char __pyx_k_iou_locals__len[] = "iou.<locals>._len";
+static const char __pyx_k_frUncompressedRLE[] = "frUncompressedRLE";
+static const char __pyx_k_iou_locals__bbIou[] = "iou.<locals>._bbIou";
+static const char __pyx_k_pycocotools__mask[] = "pycocotools._mask";
+static const char __pyx_k_iou_locals__rleIou[] = "iou.<locals>._rleIou";
+static const char __pyx_k_iou_locals__preproc[] = "iou.<locals>._preproc";
+static const char __pyx_k_input_data_type_not_allowed[] = "input data type not allowed.";
+static const char __pyx_k_input_type_is_not_supported[] = "input type is not supported.";
+static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous";
+static const char __pyx_k_Python_version_must_be_2_or_3[] = "Python version must be 2 or 3";
+static const char __pyx_k_home_yjr_PycharmProjects_Faster[] = "/home/yjr/PycharmProjects/Faster-RCNN_TF/data/lib_coco/PythonAPI/pycocotools/_mask.pyx";
+static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import";
+static const char __pyx_k_numpy_ndarray_input_is_only_for[] = "numpy ndarray input is only for *bounding boxes* and should have Nx4 dimension";
+static const char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)";
+static const char __pyx_k_unrecognized_type_The_following[] = "unrecognized type.  The following type: RLEs (rle), np.ndarray (box), and list (box) are supported.";
+static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd";
+static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported";
+static const char __pyx_k_The_dt_and_gt_should_have_the_sa[] = "The dt and gt should have the same data type, either RLEs, list or np.ndarray";
+static const char __pyx_k_list_input_can_be_bounding_box_N[] = "list input can be bounding box (Nx4) or RLEs ([RLE])";
+static const char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous";
+static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import";
+static const char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short.";
+static PyObject *__pyx_n_s_AttributeError;
+static PyObject *__pyx_n_s_F;
+static PyObject *__pyx_kp_u_Format_string_allocated_too_shor;
+static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2;
+static PyObject *__pyx_n_s_ImportError;
+static PyObject *__pyx_n_s_N;
+static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor;
+static PyObject *__pyx_n_s_PYTHON_VERSION;
+static PyObject *__pyx_kp_s_Python_version_must_be_2_or_3;
+static PyObject *__pyx_n_s_R;
+static PyObject *__pyx_n_s_Rs;
+static PyObject *__pyx_n_s_RuntimeError;
+static PyObject *__pyx_kp_s_The_dt_and_gt_should_have_the_sa;
+static PyObject *__pyx_n_s_ValueError;
+static PyObject *__pyx_n_s_a;
+static PyObject *__pyx_n_s_a_2;
+static PyObject *__pyx_n_s_all;
+static PyObject *__pyx_n_s_area;
+static PyObject *__pyx_n_s_array;
+static PyObject *__pyx_n_s_astype;
+static PyObject *__pyx_n_s_author;
+static PyObject *__pyx_n_s_bb;
+static PyObject *__pyx_n_s_bbIou;
+static PyObject *__pyx_n_s_bb_2;
+static PyObject *__pyx_n_s_c_string;
+static PyObject *__pyx_n_s_cnts;
+static PyObject *__pyx_n_s_counts;
+static PyObject *__pyx_n_s_data;
+static PyObject *__pyx_n_s_decode;
+static PyObject *__pyx_n_s_double;
+static PyObject *__pyx_n_s_dt;
+static PyObject *__pyx_n_s_dtype;
+static PyObject *__pyx_n_s_encode;
+static PyObject *__pyx_n_s_enumerate;
+static PyObject *__pyx_n_s_frBbox;
+static PyObject *__pyx_n_s_frPoly;
+static PyObject *__pyx_n_s_frPyObjects;
+static PyObject *__pyx_n_s_frString;
+static PyObject *__pyx_n_s_frUncompressedRLE;
+static PyObject *__pyx_n_s_gt;
+static PyObject *__pyx_n_s_h;
+static PyObject *__pyx_kp_s_home_yjr_PycharmProjects_Faster;
+static PyObject *__pyx_n_s_i;
+static PyObject *__pyx_n_s_import;
+static PyObject *__pyx_kp_s_input_data_type_not_allowed;
+static PyObject *__pyx_kp_s_input_type_is_not_supported;
+static PyObject *__pyx_n_s_intersect;
+static PyObject *__pyx_n_s_iou;
+static PyObject *__pyx_n_s_iouFun;
+static PyObject *__pyx_n_s_iou_2;
+static PyObject *__pyx_n_s_iou_locals__bbIou;
+static PyObject *__pyx_n_s_iou_locals__len;
+static PyObject *__pyx_n_s_iou_locals__preproc;
+static PyObject *__pyx_n_s_iou_locals__rleIou;
+static PyObject *__pyx_n_s_isbox;
+static PyObject *__pyx_n_s_iscrowd;
+static PyObject *__pyx_n_s_isrle;
+static PyObject *__pyx_n_s_j;
+static PyObject *__pyx_n_s_len;
+static PyObject *__pyx_kp_s_list_input_can_be_bounding_box_N;
+static PyObject *__pyx_n_s_m;
+static PyObject *__pyx_n_s_main;
+static PyObject *__pyx_n_s_mask;
+static PyObject *__pyx_n_s_masks;
+static PyObject *__pyx_n_s_merge;
+static PyObject *__pyx_n_s_n;
+static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous;
+static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou;
+static PyObject *__pyx_n_s_np;
+static PyObject *__pyx_n_s_np_poly;
+static PyObject *__pyx_n_s_numpy;
+static PyObject *__pyx_kp_s_numpy_core_multiarray_failed_to;
+static PyObject *__pyx_kp_s_numpy_core_umath_failed_to_impor;
+static PyObject *__pyx_kp_s_numpy_ndarray_input_is_only_for;
+static PyObject *__pyx_n_s_obj;
+static PyObject *__pyx_n_s_objs;
+static PyObject *__pyx_n_s_order;
+static PyObject *__pyx_n_s_p;
+static PyObject *__pyx_n_s_poly;
+static PyObject *__pyx_n_s_preproc;
+static PyObject *__pyx_n_s_py_string;
+static PyObject *__pyx_n_s_pycocotools__mask;
+static PyObject *__pyx_n_s_pyiscrowd;
+static PyObject *__pyx_n_s_pyobj;
+static PyObject *__pyx_n_s_range;
+static PyObject *__pyx_n_s_reshape;
+static PyObject *__pyx_n_s_rleIou;
+static PyObject *__pyx_n_s_rleObjs;
+static PyObject *__pyx_n_s_shape;
+static PyObject *__pyx_n_s_size;
+static PyObject *__pyx_n_s_sys;
+static PyObject *__pyx_n_s_test;
+static PyObject *__pyx_n_s_toBbox;
+static PyObject *__pyx_n_s_toString;
+static PyObject *__pyx_n_s_tsungyi;
+static PyObject *__pyx_n_s_ucRles;
+static PyObject *__pyx_n_s_uint32;
+static PyObject *__pyx_n_s_uint8;
+static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd;
+static PyObject *__pyx_kp_s_unrecognized_type_The_following;
+static PyObject *__pyx_n_s_utf8;
+static PyObject *__pyx_n_s_version_info;
+static PyObject *__pyx_n_s_w;
+static PyObject *__pyx_n_s_zeros;
+static int __pyx_pf_11pycocotools_5_mask_4RLEs___cinit__(struct __pyx_obj_11pycocotools_5_mask_RLEs *__pyx_v_self, siz __pyx_v_n); /* proto */
+static void __pyx_pf_11pycocotools_5_mask_4RLEs_2__dealloc__(struct __pyx_obj_11pycocotools_5_mask_RLEs *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_11pycocotools_5_mask_4RLEs_4__getattr__(struct __pyx_obj_11pycocotools_5_mask_RLEs *__pyx_v_self, PyObject *__pyx_v_key); /* proto */
+static int __pyx_pf_11pycocotools_5_mask_5Masks___cinit__(struct __pyx_obj_11pycocotools_5_mask_Masks *__pyx_v_self, PyObject *__pyx_v_h, PyObject *__pyx_v_w, PyObject *__pyx_v_n); /* proto */
+static PyObject *__pyx_pf_11pycocotools_5_mask_5Masks_2__array__(struct __pyx_obj_11pycocotools_5_mask_Masks *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_11pycocotools_5_mask__toString(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_11pycocotools_5_mask_RLEs *__pyx_v_Rs); /* proto */
+static PyObject *__pyx_pf_11pycocotools_5_mask_2_frString(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_rleObjs); /* proto */
+static PyObject *__pyx_pf_11pycocotools_5_mask_4encode(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_mask); /* proto */
+static PyObject *__pyx_pf_11pycocotools_5_mask_6decode(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_rleObjs); /* proto */
+static PyObject *__pyx_pf_11pycocotools_5_mask_8merge(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_rleObjs, PyObject *__pyx_v_intersect); /* proto */
+static PyObject *__pyx_pf_11pycocotools_5_mask_10area(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_rleObjs); /* proto */
+static PyObject *__pyx_pf_11pycocotools_5_mask_3iou__preproc(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_objs); /* proto */
+static PyObject *__pyx_pf_11pycocotools_5_mask_3iou_2_rleIou(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_11pycocotools_5_mask_RLEs *__pyx_v_dt, struct __pyx_obj_11pycocotools_5_mask_RLEs *__pyx_v_gt, PyArrayObject *__pyx_v_iscrowd, siz __pyx_v_m, siz __pyx_v_n, PyArrayObject *__pyx_v__iou); /* proto */
+static PyObject *__pyx_pf_11pycocotools_5_mask_3iou_4_bbIou(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_dt, PyArrayObject *__pyx_v_gt, PyArrayObject *__pyx_v_iscrowd, siz __pyx_v_m, siz __pyx_v_n, PyArrayObject *__pyx_v__iou); /* proto */
+static PyObject *__pyx_pf_11pycocotools_5_mask_3iou_6_len(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_obj); /* proto */
+static PyObject *__pyx_pf_11pycocotools_5_mask_12iou(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_dt, PyObject *__pyx_v_gt, PyObject *__pyx_v_pyiscrowd); /* proto */
+static PyObject *__pyx_pf_11pycocotools_5_mask_14toBbox(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_rleObjs); /* proto */
+static PyObject *__pyx_pf_11pycocotools_5_mask_16frBbox(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_bb, siz __pyx_v_h, siz __pyx_v_w); /* proto */
+static PyObject *__pyx_pf_11pycocotools_5_mask_18frPoly(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_poly, siz __pyx_v_h, siz __pyx_v_w); /* proto */
+static PyObject *__pyx_pf_11pycocotools_5_mask_20frUncompressedRLE(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ucRles, CYTHON_UNUSED siz __pyx_v_h, CYTHON_UNUSED siz __pyx_v_w); /* proto */
+static PyObject *__pyx_pf_11pycocotools_5_mask_22frPyObjects(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_pyobj, PyObject *__pyx_v_h, PyObject *__pyx_v_w); /* proto */
+static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */
+static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */
+static PyObject *__pyx_tp_new_11pycocotools_5_mask_RLEs(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_11pycocotools_5_mask_Masks(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_int_0;
+static PyObject *__pyx_int_1;
+static PyObject *__pyx_int_2;
+static PyObject *__pyx_int_3;
+static PyObject *__pyx_int_4;
+static PyObject *__pyx_tuple_;
+static PyObject *__pyx_tuple__2;
+static PyObject *__pyx_tuple__3;
+static PyObject *__pyx_tuple__4;
+static PyObject *__pyx_tuple__5;
+static PyObject *__pyx_tuple__6;
+static PyObject *__pyx_tuple__7;
+static PyObject *__pyx_tuple__9;
+static PyObject *__pyx_tuple__11;
+static PyObject *__pyx_tuple__13;
+static PyObject *__pyx_tuple__15;
+static PyObject *__pyx_tuple__16;
+static PyObject *__pyx_tuple__17;
+static PyObject *__pyx_tuple__18;
+static PyObject *__pyx_tuple__19;
+static PyObject *__pyx_tuple__20;
+static PyObject *__pyx_tuple__21;
+static PyObject *__pyx_tuple__22;
+static PyObject *__pyx_tuple__23;
+static PyObject *__pyx_tuple__24;
+static PyObject *__pyx_tuple__25;
+static PyObject *__pyx_tuple__26;
+static PyObject *__pyx_tuple__27;
+static PyObject *__pyx_tuple__28;
+static PyObject *__pyx_tuple__30;
+static PyObject *__pyx_tuple__32;
+static PyObject *__pyx_tuple__34;
+static PyObject *__pyx_tuple__36;
+static PyObject *__pyx_tuple__38;
+static PyObject *__pyx_tuple__40;
+static PyObject *__pyx_tuple__42;
+static PyObject *__pyx_tuple__44;
+static PyObject *__pyx_tuple__46;
+static PyObject *__pyx_tuple__48;
+static PyObject *__pyx_tuple__50;
+static PyObject *__pyx_codeobj__8;
+static PyObject *__pyx_codeobj__10;
+static PyObject *__pyx_codeobj__12;
+static PyObject *__pyx_codeobj__14;
+static PyObject *__pyx_codeobj__29;
+static PyObject *__pyx_codeobj__31;
+static PyObject *__pyx_codeobj__33;
+static PyObject *__pyx_codeobj__35;
+static PyObject *__pyx_codeobj__37;
+static PyObject *__pyx_codeobj__39;
+static PyObject *__pyx_codeobj__41;
+static PyObject *__pyx_codeobj__43;
+static PyObject *__pyx_codeobj__45;
+static PyObject *__pyx_codeobj__47;
+static PyObject *__pyx_codeobj__49;
+static PyObject *__pyx_codeobj__51;
+
+/* "pycocotools/_mask.pyx":60
+ *     cdef siz _n
+ * 
+ *     def __cinit__(self, siz n =0):             # <<<<<<<<<<<<<<
+ *         rlesInit(&self._R, n)
+ *         self._n = n
+ */
+
+/* Python wrapper */
+static int __pyx_pw_11pycocotools_5_mask_4RLEs_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_11pycocotools_5_mask_4RLEs_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  siz __pyx_v_n;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_n,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_n);
+          if (value) { values[0] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(0, 60, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    if (values[0]) {
+      __pyx_v_n = __Pyx_PyInt_As_siz(values[0]); if (unlikely((__pyx_v_n == ((siz)-1)) && PyErr_Occurred())) __PYX_ERR(0, 60, __pyx_L3_error)
+    } else {
+      __pyx_v_n = ((siz)0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 60, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pycocotools._mask.RLEs.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_11pycocotools_5_mask_4RLEs___cinit__(((struct __pyx_obj_11pycocotools_5_mask_RLEs *)__pyx_v_self), __pyx_v_n);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_11pycocotools_5_mask_4RLEs___cinit__(struct __pyx_obj_11pycocotools_5_mask_RLEs *__pyx_v_self, siz __pyx_v_n) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pycocotools/_mask.pyx":61
+ * 
+ *     def __cinit__(self, siz n =0):
+ *         rlesInit(&self._R, n)             # <<<<<<<<<<<<<<
+ *         self._n = n
+ * 
+ */
+  rlesInit((&__pyx_v_self->_R), __pyx_v_n);
+
+  /* "pycocotools/_mask.pyx":62
+ *     def __cinit__(self, siz n =0):
+ *         rlesInit(&self._R, n)
+ *         self._n = n             # <<<<<<<<<<<<<<
+ * 
+ *     # free the RLE array here
+ */
+  __pyx_v_self->_n = __pyx_v_n;
+
+  /* "pycocotools/_mask.pyx":60
+ *     cdef siz _n
+ * 
+ *     def __cinit__(self, siz n =0):             # <<<<<<<<<<<<<<
+ *         rlesInit(&self._R, n)
+ *         self._n = n
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pycocotools/_mask.pyx":65
+ * 
+ *     # free the RLE array here
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         if self._R is not NULL:
+ *             for i in range(self._n):
+ */
+
+/* Python wrapper */
+static void __pyx_pw_11pycocotools_5_mask_4RLEs_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_11pycocotools_5_mask_4RLEs_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_11pycocotools_5_mask_4RLEs_2__dealloc__(((struct __pyx_obj_11pycocotools_5_mask_RLEs *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_11pycocotools_5_mask_4RLEs_2__dealloc__(struct __pyx_obj_11pycocotools_5_mask_RLEs *__pyx_v_self) {
+  siz __pyx_v_i;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  siz __pyx_t_2;
+  siz __pyx_t_3;
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pycocotools/_mask.pyx":66
+ *     # free the RLE array here
+ *     def __dealloc__(self):
+ *         if self._R is not NULL:             # <<<<<<<<<<<<<<
+ *             for i in range(self._n):
+ *                 free(self._R[i].cnts)
+ */
+  __pyx_t_1 = ((__pyx_v_self->_R != NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "pycocotools/_mask.pyx":67
+ *     def __dealloc__(self):
+ *         if self._R is not NULL:
+ *             for i in range(self._n):             # <<<<<<<<<<<<<<
+ *                 free(self._R[i].cnts)
+ *             free(self._R)
+ */
+    __pyx_t_2 = __pyx_v_self->_n;
+    for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+      __pyx_v_i = __pyx_t_3;
+
+      /* "pycocotools/_mask.pyx":68
+ *         if self._R is not NULL:
+ *             for i in range(self._n):
+ *                 free(self._R[i].cnts)             # <<<<<<<<<<<<<<
+ *             free(self._R)
+ *     def __getattr__(self, key):
+ */
+      free((__pyx_v_self->_R[__pyx_v_i]).cnts);
+    }
+
+    /* "pycocotools/_mask.pyx":69
+ *             for i in range(self._n):
+ *                 free(self._R[i].cnts)
+ *             free(self._R)             # <<<<<<<<<<<<<<
+ *     def __getattr__(self, key):
+ *         if key == 'n':
+ */
+    free(__pyx_v_self->_R);
+
+    /* "pycocotools/_mask.pyx":66
+ *     # free the RLE array here
+ *     def __dealloc__(self):
+ *         if self._R is not NULL:             # <<<<<<<<<<<<<<
+ *             for i in range(self._n):
+ *                 free(self._R[i].cnts)
+ */
+  }
+
+  /* "pycocotools/_mask.pyx":65
+ * 
+ *     # free the RLE array here
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         if self._R is not NULL:
+ *             for i in range(self._n):
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pycocotools/_mask.pyx":70
+ *                 free(self._R[i].cnts)
+ *             free(self._R)
+ *     def __getattr__(self, key):             # <<<<<<<<<<<<<<
+ *         if key == 'n':
+ *             return self._n
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11pycocotools_5_mask_4RLEs_5__getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/
+static PyObject *__pyx_pw_11pycocotools_5_mask_4RLEs_5__getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_key) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_11pycocotools_5_mask_4RLEs_4__getattr__(((struct __pyx_obj_11pycocotools_5_mask_RLEs *)__pyx_v_self), ((PyObject *)__pyx_v_key));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_11pycocotools_5_mask_4RLEs_4__getattr__(struct __pyx_obj_11pycocotools_5_mask_RLEs *__pyx_v_self, PyObject *__pyx_v_key) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("__getattr__", 0);
+
+  /* "pycocotools/_mask.pyx":71
+ *             free(self._R)
+ *     def __getattr__(self, key):
+ *         if key == 'n':             # <<<<<<<<<<<<<<
+ *             return self._n
+ *         raise AttributeError(key)
+ */
+  __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_key, __pyx_n_s_n, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 71, __pyx_L1_error)
+  if (__pyx_t_1) {
+
+    /* "pycocotools/_mask.pyx":72
+ *     def __getattr__(self, key):
+ *         if key == 'n':
+ *             return self._n             # <<<<<<<<<<<<<<
+ *         raise AttributeError(key)
+ * 
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_2 = __Pyx_PyInt_From_siz(__pyx_v_self->_n); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 72, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_r = __pyx_t_2;
+    __pyx_t_2 = 0;
+    goto __pyx_L0;
+
+    /* "pycocotools/_mask.pyx":71
+ *             free(self._R)
+ *     def __getattr__(self, key):
+ *         if key == 'n':             # <<<<<<<<<<<<<<
+ *             return self._n
+ *         raise AttributeError(key)
+ */
+  }
+
+  /* "pycocotools/_mask.pyx":73
+ *         if key == 'n':
+ *             return self._n
+ *         raise AttributeError(key)             # <<<<<<<<<<<<<<
+ * 
+ * # python class to wrap Mask array in C
+ */
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 73, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_v_key);
+  __Pyx_GIVEREF(__pyx_v_key);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_key);
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 73, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __PYX_ERR(0, 73, __pyx_L1_error)
+
+  /* "pycocotools/_mask.pyx":70
+ *                 free(self._R[i].cnts)
+ *             free(self._R)
+ *     def __getattr__(self, key):             # <<<<<<<<<<<<<<
+ *         if key == 'n':
+ *             return self._n
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pycocotools._mask.RLEs.__getattr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pycocotools/_mask.pyx":83
+ *     cdef siz _n
+ * 
+ *     def __cinit__(self, h, w, n):             # <<<<<<<<<<<<<<
+ *         self._mask = <byte*> malloc(h*w*n* sizeof(byte))
+ *         self._h = h
+ */
+
+/* Python wrapper */
+static int __pyx_pw_11pycocotools_5_mask_5Masks_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_11pycocotools_5_mask_5Masks_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_h = 0;
+  PyObject *__pyx_v_w = 0;
+  PyObject *__pyx_v_n = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_h,&__pyx_n_s_w,&__pyx_n_s_n,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_h)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_w)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, 1); __PYX_ERR(0, 83, __pyx_L3_error)
+        }
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_n)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, 2); __PYX_ERR(0, 83, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(0, 83, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    }
+    __pyx_v_h = values[0];
+    __pyx_v_w = values[1];
+    __pyx_v_n = values[2];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 83, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pycocotools._mask.Masks.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_11pycocotools_5_mask_5Masks___cinit__(((struct __pyx_obj_11pycocotools_5_mask_Masks *)__pyx_v_self), __pyx_v_h, __pyx_v_w, __pyx_v_n);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_11pycocotools_5_mask_5Masks___cinit__(struct __pyx_obj_11pycocotools_5_mask_Masks *__pyx_v_self, PyObject *__pyx_v_h, PyObject *__pyx_v_w, PyObject *__pyx_v_n) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  size_t __pyx_t_4;
+  siz __pyx_t_5;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pycocotools/_mask.pyx":84
+ * 
+ *     def __cinit__(self, h, w, n):
+ *         self._mask = <byte*> malloc(h*w*n* sizeof(byte))             # <<<<<<<<<<<<<<
+ *         self._h = h
+ *         self._w = w
+ */
+  __pyx_t_1 = PyNumber_Multiply(__pyx_v_h, __pyx_v_w); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 84, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_n); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 84, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_FromSize_t((sizeof(byte))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 84, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = PyNumber_Multiply(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 84, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_4 = __Pyx_PyInt_As_size_t(__pyx_t_3); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 84, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_self->_mask = ((byte *)malloc(__pyx_t_4));
+
+  /* "pycocotools/_mask.pyx":85
+ *     def __cinit__(self, h, w, n):
+ *         self._mask = <byte*> malloc(h*w*n* sizeof(byte))
+ *         self._h = h             # <<<<<<<<<<<<<<
+ *         self._w = w
+ *         self._n = n
+ */
+  __pyx_t_5 = __Pyx_PyInt_As_siz(__pyx_v_h); if (unlikely((__pyx_t_5 == ((siz)-1)) && PyErr_Occurred())) __PYX_ERR(0, 85, __pyx_L1_error)
+  __pyx_v_self->_h = __pyx_t_5;
+
+  /* "pycocotools/_mask.pyx":86
+ *         self._mask = <byte*> malloc(h*w*n* sizeof(byte))
+ *         self._h = h
+ *         self._w = w             # <<<<<<<<<<<<<<
+ *         self._n = n
+ *     # def __dealloc__(self):
+ */
+  __pyx_t_5 = __Pyx_PyInt_As_siz(__pyx_v_w); if (unlikely((__pyx_t_5 == ((siz)-1)) && PyErr_Occurred())) __PYX_ERR(0, 86, __pyx_L1_error)
+  __pyx_v_self->_w = __pyx_t_5;
+
+  /* "pycocotools/_mask.pyx":87
+ *         self._h = h
+ *         self._w = w
+ *         self._n = n             # <<<<<<<<<<<<<<
+ *     # def __dealloc__(self):
+ *         # the memory management of _mask has been passed to np.ndarray
+ */
+  __pyx_t_5 = __Pyx_PyInt_As_siz(__pyx_v_n); if (unlikely((__pyx_t_5 == ((siz)-1)) && PyErr_Occurred())) __PYX_ERR(0, 87, __pyx_L1_error)
+  __pyx_v_self->_n = __pyx_t_5;
+
+  /* "pycocotools/_mask.pyx":83
+ *     cdef siz _n
+ * 
+ *     def __cinit__(self, h, w, n):             # <<<<<<<<<<<<<<
+ *         self._mask = <byte*> malloc(h*w*n* sizeof(byte))
+ *         self._h = h
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pycocotools._mask.Masks.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pycocotools/_mask.pyx":93
+ * 
+ *     # called when passing into np.array() and return an np.ndarray in column-major order
+ *     def __array__(self):             # <<<<<<<<<<<<<<
+ *         cdef np.npy_intp shape[1]
+ *         shape[0] = <np.npy_intp> self._h*self._w*self._n
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11pycocotools_5_mask_5Masks_3__array__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_11pycocotools_5_mask_5Masks_3__array__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__array__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_11pycocotools_5_mask_5Masks_2__array__(((struct __pyx_obj_11pycocotools_5_mask_Masks *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_11pycocotools_5_mask_5Masks_2__array__(struct __pyx_obj_11pycocotools_5_mask_Masks *__pyx_v_self) {
+  npy_intp __pyx_v_shape[1];
+  PyObject *__pyx_v_ndarray = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  __Pyx_RefNannySetupContext("__array__", 0);
+
+  /* "pycocotools/_mask.pyx":95
+ *     def __array__(self):
+ *         cdef np.npy_intp shape[1]
+ *         shape[0] = <np.npy_intp> self._h*self._w*self._n             # <<<<<<<<<<<<<<
+ *         # Create a 1D array, and reshape it to fortran/Matlab column-major array
+ *         ndarray = np.PyArray_SimpleNewFromData(1, shape, np.NPY_UINT8, self._mask).reshape((self._h, self._w, self._n), order='F')
+ */
+  (__pyx_v_shape[0]) = ((((npy_intp)__pyx_v_self->_h) * __pyx_v_self->_w) * __pyx_v_self->_n);
+
+  /* "pycocotools/_mask.pyx":97
+ *         shape[0] = <np.npy_intp> self._h*self._w*self._n
+ *         # Create a 1D array, and reshape it to fortran/Matlab column-major array
+ *         ndarray = np.PyArray_SimpleNewFromData(1, shape, np.NPY_UINT8, self._mask).reshape((self._h, self._w, self._n), order='F')             # <<<<<<<<<<<<<<
+ *         # The _mask allocated by Masks is now handled by ndarray
+ *         PyArray_ENABLEFLAGS(ndarray, np.NPY_OWNDATA)
+ */
+  __pyx_t_1 = PyArray_SimpleNewFromData(1, __pyx_v_shape, NPY_UINT8, __pyx_v_self->_mask); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_reshape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_siz(__pyx_v_self->_h); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyInt_From_siz(__pyx_v_self->_w); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyInt_From_siz(__pyx_v_self->_n); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4);
+  __pyx_t_1 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
+  __pyx_t_5 = 0;
+  __pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_order, __pyx_n_s_F) < 0) __PYX_ERR(0, 97, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_v_ndarray = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "pycocotools/_mask.pyx":99
+ *         ndarray = np.PyArray_SimpleNewFromData(1, shape, np.NPY_UINT8, self._mask).reshape((self._h, self._w, self._n), order='F')
+ *         # The _mask allocated by Masks is now handled by ndarray
+ *         PyArray_ENABLEFLAGS(ndarray, np.NPY_OWNDATA)             # <<<<<<<<<<<<<<
+ *         return ndarray
+ * 
+ */
+  if (!(likely(((__pyx_v_ndarray) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_ndarray, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 99, __pyx_L1_error)
+  PyArray_ENABLEFLAGS(((PyArrayObject *)__pyx_v_ndarray), NPY_OWNDATA);
+
+  /* "pycocotools/_mask.pyx":100
+ *         # The _mask allocated by Masks is now handled by ndarray
+ *         PyArray_ENABLEFLAGS(ndarray, np.NPY_OWNDATA)
+ *         return ndarray             # <<<<<<<<<<<<<<
+ * 
+ * # internal conversion from Python RLEs object to compressed RLE format
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_ndarray);
+  __pyx_r = __pyx_v_ndarray;
+  goto __pyx_L0;
+
+  /* "pycocotools/_mask.pyx":93
+ * 
+ *     # called when passing into np.array() and return an np.ndarray in column-major order
+ *     def __array__(self):             # <<<<<<<<<<<<<<
+ *         cdef np.npy_intp shape[1]
+ *         shape[0] = <np.npy_intp> self._h*self._w*self._n
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("pycocotools._mask.Masks.__array__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_ndarray);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pycocotools/_mask.pyx":103
+ * 
+ * # internal conversion from Python RLEs object to compressed RLE format
+ * def _toString(RLEs Rs):             # <<<<<<<<<<<<<<
+ *     cdef siz n = Rs.n
+ *     cdef bytes py_string
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11pycocotools_5_mask_1_toString(PyObject *__pyx_self, PyObject *__pyx_v_Rs); /*proto*/
+static PyMethodDef __pyx_mdef_11pycocotools_5_mask_1_toString = {"_toString", (PyCFunction)__pyx_pw_11pycocotools_5_mask_1_toString, METH_O, 0};
+static PyObject *__pyx_pw_11pycocotools_5_mask_1_toString(PyObject *__pyx_self, PyObject *__pyx_v_Rs) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_toString (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Rs), __pyx_ptype_11pycocotools_5_mask_RLEs, 1, "Rs", 0))) __PYX_ERR(0, 103, __pyx_L1_error)
+  __pyx_r = __pyx_pf_11pycocotools_5_mask__toString(__pyx_self, ((struct __pyx_obj_11pycocotools_5_mask_RLEs *)__pyx_v_Rs));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_11pycocotools_5_mask__toString(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_11pycocotools_5_mask_RLEs *__pyx_v_Rs) {
+  siz __pyx_v_n;
+  PyObject *__pyx_v_py_string = 0;
+  char *__pyx_v_c_string;
+  PyObject *__pyx_v_objs = NULL;
+  siz __pyx_v_i;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  siz __pyx_t_2;
+  siz __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  __Pyx_RefNannySetupContext("_toString", 0);
+
+  /* "pycocotools/_mask.pyx":104
+ * # internal conversion from Python RLEs object to compressed RLE format
+ * def _toString(RLEs Rs):
+ *     cdef siz n = Rs.n             # <<<<<<<<<<<<<<
+ *     cdef bytes py_string
+ *     cdef char* c_string
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_Rs), __pyx_n_s_n); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 104, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_As_siz(__pyx_t_1); if (unlikely((__pyx_t_2 == ((siz)-1)) && PyErr_Occurred())) __PYX_ERR(0, 104, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_n = __pyx_t_2;
+
+  /* "pycocotools/_mask.pyx":107
+ *     cdef bytes py_string
+ *     cdef char* c_string
+ *     objs = []             # <<<<<<<<<<<<<<
+ *     for i in range(n):
+ *         c_string = rleToString( <RLE*> &Rs._R[i] )
+ */
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 107, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_objs = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":108
+ *     cdef char* c_string
+ *     objs = []
+ *     for i in range(n):             # <<<<<<<<<<<<<<
+ *         c_string = rleToString( <RLE*> &Rs._R[i] )
+ *         py_string = c_string
+ */
+  __pyx_t_2 = __pyx_v_n;
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+
+    /* "pycocotools/_mask.pyx":109
+ *     objs = []
+ *     for i in range(n):
+ *         c_string = rleToString( <RLE*> &Rs._R[i] )             # <<<<<<<<<<<<<<
+ *         py_string = c_string
+ *         objs.append({
+ */
+    __pyx_v_c_string = rleToString(((RLE *)(&(__pyx_v_Rs->_R[__pyx_v_i]))));
+
+    /* "pycocotools/_mask.pyx":110
+ *     for i in range(n):
+ *         c_string = rleToString( <RLE*> &Rs._R[i] )
+ *         py_string = c_string             # <<<<<<<<<<<<<<
+ *         objs.append({
+ *             'size': [Rs._R[i].h, Rs._R[i].w],
+ */
+    __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_c_string); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 110, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_XDECREF_SET(__pyx_v_py_string, ((PyObject*)__pyx_t_1));
+    __pyx_t_1 = 0;
+
+    /* "pycocotools/_mask.pyx":112
+ *         py_string = c_string
+ *         objs.append({
+ *             'size': [Rs._R[i].h, Rs._R[i].w],             # <<<<<<<<<<<<<<
+ *             'counts': py_string
+ *         })
+ */
+    __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_4 = __Pyx_PyInt_From_siz((__pyx_v_Rs->_R[__pyx_v_i]).h); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 112, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = __Pyx_PyInt_From_siz((__pyx_v_Rs->_R[__pyx_v_i]).w); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 112, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = PyList_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 112, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyList_SET_ITEM(__pyx_t_6, 0, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyList_SET_ITEM(__pyx_t_6, 1, __pyx_t_5);
+    __pyx_t_4 = 0;
+    __pyx_t_5 = 0;
+    if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_size, __pyx_t_6) < 0) __PYX_ERR(0, 112, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+    /* "pycocotools/_mask.pyx":114
+ *             'size': [Rs._R[i].h, Rs._R[i].w],
+ *             'counts': py_string
+ *         })             # <<<<<<<<<<<<<<
+ *         free(c_string)
+ *     return objs
+ */
+    if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_counts, __pyx_v_py_string) < 0) __PYX_ERR(0, 112, __pyx_L1_error)
+
+    /* "pycocotools/_mask.pyx":111
+ *         c_string = rleToString( <RLE*> &Rs._R[i] )
+ *         py_string = c_string
+ *         objs.append({             # <<<<<<<<<<<<<<
+ *             'size': [Rs._R[i].h, Rs._R[i].w],
+ *             'counts': py_string
+ */
+    __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_objs, __pyx_t_1); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 111, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "pycocotools/_mask.pyx":115
+ *             'counts': py_string
+ *         })
+ *         free(c_string)             # <<<<<<<<<<<<<<
+ *     return objs
+ * 
+ */
+    free(__pyx_v_c_string);
+  }
+
+  /* "pycocotools/_mask.pyx":116
+ *         })
+ *         free(c_string)
+ *     return objs             # <<<<<<<<<<<<<<
+ * 
+ * # internal conversion from compressed RLE format to Python RLEs object
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_objs);
+  __pyx_r = __pyx_v_objs;
+  goto __pyx_L0;
+
+  /* "pycocotools/_mask.pyx":103
+ * 
+ * # internal conversion from Python RLEs object to compressed RLE format
+ * def _toString(RLEs Rs):             # <<<<<<<<<<<<<<
+ *     cdef siz n = Rs.n
+ *     cdef bytes py_string
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("pycocotools._mask._toString", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_py_string);
+  __Pyx_XDECREF(__pyx_v_objs);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pycocotools/_mask.pyx":119
+ * 
+ * # internal conversion from compressed RLE format to Python RLEs object
+ * def _frString(rleObjs):             # <<<<<<<<<<<<<<
+ *     cdef siz n = len(rleObjs)
+ *     Rs = RLEs(n)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11pycocotools_5_mask_3_frString(PyObject *__pyx_self, PyObject *__pyx_v_rleObjs); /*proto*/
+static PyMethodDef __pyx_mdef_11pycocotools_5_mask_3_frString = {"_frString", (PyCFunction)__pyx_pw_11pycocotools_5_mask_3_frString, METH_O, 0};
+static PyObject *__pyx_pw_11pycocotools_5_mask_3_frString(PyObject *__pyx_self, PyObject *__pyx_v_rleObjs) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_frString (wrapper)", 0);
+  __pyx_r = __pyx_pf_11pycocotools_5_mask_2_frString(__pyx_self, ((PyObject *)__pyx_v_rleObjs));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_11pycocotools_5_mask_2_frString(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_rleObjs) {
+  siz __pyx_v_n;
+  struct __pyx_obj_11pycocotools_5_mask_RLEs *__pyx_v_Rs = NULL;
+  PyObject *__pyx_v_py_string = 0;
+  char *__pyx_v_c_string;
+  PyObject *__pyx_v_i = NULL;
+  PyObject *__pyx_v_obj = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Py_ssize_t __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *(*__pyx_t_4)(PyObject *);
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  char *__pyx_t_12;
+  Py_ssize_t __pyx_t_13;
+  siz __pyx_t_14;
+  siz __pyx_t_15;
+  __Pyx_RefNannySetupContext("_frString", 0);
+
+  /* "pycocotools/_mask.pyx":120
+ * # internal conversion from compressed RLE format to Python RLEs object
+ * def _frString(rleObjs):
+ *     cdef siz n = len(rleObjs)             # <<<<<<<<<<<<<<
+ *     Rs = RLEs(n)
+ *     cdef bytes py_string
+ */
+  __pyx_t_1 = PyObject_Length(__pyx_v_rleObjs); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(0, 120, __pyx_L1_error)
+  __pyx_v_n = __pyx_t_1;
+
+  /* "pycocotools/_mask.pyx":121
+ * def _frString(rleObjs):
+ *     cdef siz n = len(rleObjs)
+ *     Rs = RLEs(n)             # <<<<<<<<<<<<<<
+ *     cdef bytes py_string
+ *     cdef char* c_string
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_siz(__pyx_v_n); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 121, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 121, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_11pycocotools_5_mask_RLEs), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 121, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_Rs = ((struct __pyx_obj_11pycocotools_5_mask_RLEs *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "pycocotools/_mask.pyx":124
+ *     cdef bytes py_string
+ *     cdef char* c_string
+ *     for i, obj in enumerate(rleObjs):             # <<<<<<<<<<<<<<
+ *         if PYTHON_VERSION == 2:
+ *             py_string = str(obj['counts']).encode('utf8')
+ */
+  __Pyx_INCREF(__pyx_int_0);
+  __pyx_t_2 = __pyx_int_0;
+  if (likely(PyList_CheckExact(__pyx_v_rleObjs)) || PyTuple_CheckExact(__pyx_v_rleObjs)) {
+    __pyx_t_3 = __pyx_v_rleObjs; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0;
+    __pyx_t_4 = NULL;
+  } else {
+    __pyx_t_1 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_rleObjs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 124, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 124, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_4)) {
+      if (likely(PyList_CheckExact(__pyx_t_3))) {
+        if (__pyx_t_1 >= PyList_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_5 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(0, 124, __pyx_L1_error)
+        #else
+        __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 124, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        #endif
+      } else {
+        if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(0, 124, __pyx_L1_error)
+        #else
+        __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 124, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        #endif
+      }
+    } else {
+      __pyx_t_5 = __pyx_t_4(__pyx_t_3);
+      if (unlikely(!__pyx_t_5)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(0, 124, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_5);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_obj, __pyx_t_5);
+    __pyx_t_5 = 0;
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2);
+    __pyx_t_5 = __Pyx_PyInt_AddObjC(__pyx_t_2, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 124, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_2);
+    __pyx_t_2 = __pyx_t_5;
+    __pyx_t_5 = 0;
+
+    /* "pycocotools/_mask.pyx":125
+ *     cdef char* c_string
+ *     for i, obj in enumerate(rleObjs):
+ *         if PYTHON_VERSION == 2:             # <<<<<<<<<<<<<<
+ *             py_string = str(obj['counts']).encode('utf8')
+ *         elif PYTHON_VERSION == 3:
+ */
+    __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_PYTHON_VERSION); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 125, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = __Pyx_PyInt_EqObjC(__pyx_t_5, __pyx_int_2, 2, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 125, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 125, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (__pyx_t_7) {
+
+      /* "pycocotools/_mask.pyx":126
+ *     for i, obj in enumerate(rleObjs):
+ *         if PYTHON_VERSION == 2:
+ *             py_string = str(obj['counts']).encode('utf8')             # <<<<<<<<<<<<<<
+ *         elif PYTHON_VERSION == 3:
+ *             py_string = str.encode(obj['counts']) if type(obj['counts']) == str else obj['counts']
+ */
+      __pyx_t_6 = PyObject_GetItem(__pyx_v_obj, __pyx_n_s_counts); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 126, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 126, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_6);
+      PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6);
+      __pyx_t_6 = 0;
+      __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_5, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 126, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 126, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 126, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (!(likely(PyBytes_CheckExact(__pyx_t_6))||((__pyx_t_6) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_6)->tp_name), 0))) __PYX_ERR(0, 126, __pyx_L1_error)
+      __Pyx_XDECREF_SET(__pyx_v_py_string, ((PyObject*)__pyx_t_6));
+      __pyx_t_6 = 0;
+
+      /* "pycocotools/_mask.pyx":125
+ *     cdef char* c_string
+ *     for i, obj in enumerate(rleObjs):
+ *         if PYTHON_VERSION == 2:             # <<<<<<<<<<<<<<
+ *             py_string = str(obj['counts']).encode('utf8')
+ *         elif PYTHON_VERSION == 3:
+ */
+      goto __pyx_L5;
+    }
+
+    /* "pycocotools/_mask.pyx":127
+ *         if PYTHON_VERSION == 2:
+ *             py_string = str(obj['counts']).encode('utf8')
+ *         elif PYTHON_VERSION == 3:             # <<<<<<<<<<<<<<
+ *             py_string = str.encode(obj['counts']) if type(obj['counts']) == str else obj['counts']
+ *         else:
+ */
+    __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_PYTHON_VERSION); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 127, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_5 = __Pyx_PyInt_EqObjC(__pyx_t_6, __pyx_int_3, 3, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 127, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 127, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (__pyx_t_7) {
+
+      /* "pycocotools/_mask.pyx":128
+ *             py_string = str(obj['counts']).encode('utf8')
+ *         elif PYTHON_VERSION == 3:
+ *             py_string = str.encode(obj['counts']) if type(obj['counts']) == str else obj['counts']             # <<<<<<<<<<<<<<
+ *         else:
+ *             raise Exception('Python version must be 2 or 3')
+ */
+      __pyx_t_6 = PyObject_GetItem(__pyx_v_obj, __pyx_n_s_counts); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 128, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_t_8 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_t_6)), ((PyObject *)(&PyString_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 128, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 128, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      if (__pyx_t_7) {
+        __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)(&PyString_Type)), __pyx_n_s_encode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 128, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __pyx_t_9 = PyObject_GetItem(__pyx_v_obj, __pyx_n_s_counts); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 128, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __pyx_t_10 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+          __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_6);
+          if (likely(__pyx_t_10)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+            __Pyx_INCREF(__pyx_t_10);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_6, function);
+          }
+        }
+        if (!__pyx_t_10) {
+          __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 128, __pyx_L1_error)
+          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+          __Pyx_GOTREF(__pyx_t_8);
+        } else {
+          #if CYTHON_FAST_PYCALL
+          if (PyFunction_Check(__pyx_t_6)) {
+            PyObject *__pyx_temp[2] = {__pyx_t_10, __pyx_t_9};
+            __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 128, __pyx_L1_error)
+            __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+            __Pyx_GOTREF(__pyx_t_8);
+            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+          } else
+          #endif
+          #if CYTHON_FAST_PYCCALL
+          if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+            PyObject *__pyx_temp[2] = {__pyx_t_10, __pyx_t_9};
+            __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 128, __pyx_L1_error)
+            __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+            __Pyx_GOTREF(__pyx_t_8);
+            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+          } else
+          #endif
+          {
+            __pyx_t_11 = PyTuple_New(1+1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 128, __pyx_L1_error)
+            __Pyx_GOTREF(__pyx_t_11);
+            __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_10); __pyx_t_10 = NULL;
+            __Pyx_GIVEREF(__pyx_t_9);
+            PyTuple_SET_ITEM(__pyx_t_11, 0+1, __pyx_t_9);
+            __pyx_t_9 = 0;
+            __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_11, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 128, __pyx_L1_error)
+            __Pyx_GOTREF(__pyx_t_8);
+            __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+          }
+        }
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        if (!(likely(PyBytes_CheckExact(__pyx_t_8))||((__pyx_t_8) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_8)->tp_name), 0))) __PYX_ERR(0, 128, __pyx_L1_error)
+        __pyx_t_5 = __pyx_t_8;
+        __pyx_t_8 = 0;
+      } else {
+        __pyx_t_8 = PyObject_GetItem(__pyx_v_obj, __pyx_n_s_counts); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 128, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        if (!(likely(PyBytes_CheckExact(__pyx_t_8))||((__pyx_t_8) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_8)->tp_name), 0))) __PYX_ERR(0, 128, __pyx_L1_error)
+        __pyx_t_5 = __pyx_t_8;
+        __pyx_t_8 = 0;
+      }
+      __Pyx_XDECREF_SET(__pyx_v_py_string, ((PyObject*)__pyx_t_5));
+      __pyx_t_5 = 0;
+
+      /* "pycocotools/_mask.pyx":127
+ *         if PYTHON_VERSION == 2:
+ *             py_string = str(obj['counts']).encode('utf8')
+ *         elif PYTHON_VERSION == 3:             # <<<<<<<<<<<<<<
+ *             py_string = str.encode(obj['counts']) if type(obj['counts']) == str else obj['counts']
+ *         else:
+ */
+      goto __pyx_L5;
+    }
+
+    /* "pycocotools/_mask.pyx":130
+ *             py_string = str.encode(obj['counts']) if type(obj['counts']) == str else obj['counts']
+ *         else:
+ *             raise Exception('Python version must be 2 or 3')             # <<<<<<<<<<<<<<
+ *         c_string = py_string
+ *         rleFrString( <RLE*> &Rs._R[i], <char*> c_string, obj['size'][0], obj['size'][1] )
+ */
+    /*else*/ {
+      __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 130, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __PYX_ERR(0, 130, __pyx_L1_error)
+    }
+    __pyx_L5:;
+
+    /* "pycocotools/_mask.pyx":131
+ *         else:
+ *             raise Exception('Python version must be 2 or 3')
+ *         c_string = py_string             # <<<<<<<<<<<<<<
+ *         rleFrString( <RLE*> &Rs._R[i], <char*> c_string, obj['size'][0], obj['size'][1] )
+ *     return Rs
+ */
+    __pyx_t_12 = __Pyx_PyObject_AsString(__pyx_v_py_string); if (unlikely((!__pyx_t_12) && PyErr_Occurred())) __PYX_ERR(0, 131, __pyx_L1_error)
+    __pyx_v_c_string = __pyx_t_12;
+
+    /* "pycocotools/_mask.pyx":132
+ *             raise Exception('Python version must be 2 or 3')
+ *         c_string = py_string
+ *         rleFrString( <RLE*> &Rs._R[i], <char*> c_string, obj['size'][0], obj['size'][1] )             # <<<<<<<<<<<<<<
+ *     return Rs
+ * 
+ */
+    __pyx_t_13 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_13 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 132, __pyx_L1_error)
+    __pyx_t_5 = PyObject_GetItem(__pyx_v_obj, __pyx_n_s_size); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 132, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_5, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 132, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_14 = __Pyx_PyInt_As_siz(__pyx_t_8); if (unlikely((__pyx_t_14 == ((siz)-1)) && PyErr_Occurred())) __PYX_ERR(0, 132, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __pyx_t_8 = PyObject_GetItem(__pyx_v_obj, __pyx_n_s_size); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 132, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_8, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 132, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __pyx_t_15 = __Pyx_PyInt_As_siz(__pyx_t_5); if (unlikely((__pyx_t_15 == ((siz)-1)) && PyErr_Occurred())) __PYX_ERR(0, 132, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    rleFrString(((RLE *)(&(__pyx_v_Rs->_R[__pyx_t_13]))), ((char *)__pyx_v_c_string), __pyx_t_14, __pyx_t_15);
+
+    /* "pycocotools/_mask.pyx":124
+ *     cdef bytes py_string
+ *     cdef char* c_string
+ *     for i, obj in enumerate(rleObjs):             # <<<<<<<<<<<<<<
+ *         if PYTHON_VERSION == 2:
+ *             py_string = str(obj['counts']).encode('utf8')
+ */
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pycocotools/_mask.pyx":133
+ *         c_string = py_string
+ *         rleFrString( <RLE*> &Rs._R[i], <char*> c_string, obj['size'][0], obj['size'][1] )
+ *     return Rs             # <<<<<<<<<<<<<<
+ * 
+ * # encode mask to RLEs objects
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_Rs));
+  __pyx_r = ((PyObject *)__pyx_v_Rs);
+  goto __pyx_L0;
+
+  /* "pycocotools/_mask.pyx":119
+ * 
+ * # internal conversion from compressed RLE format to Python RLEs object
+ * def _frString(rleObjs):             # <<<<<<<<<<<<<<
+ *     cdef siz n = len(rleObjs)
+ *     Rs = RLEs(n)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_AddTraceback("pycocotools._mask._frString", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_Rs);
+  __Pyx_XDECREF(__pyx_v_py_string);
+  __Pyx_XDECREF(__pyx_v_i);
+  __Pyx_XDECREF(__pyx_v_obj);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pycocotools/_mask.pyx":137
+ * # encode mask to RLEs objects
+ * # list of RLE string can be generated by RLEs member function
+ * def encode(np.ndarray[np.uint8_t, ndim=3, mode='fortran'] mask):             # <<<<<<<<<<<<<<
+ *     h, w, n = mask.shape[0], mask.shape[1], mask.shape[2]
+ *     cdef RLEs Rs = RLEs(n)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11pycocotools_5_mask_5encode(PyObject *__pyx_self, PyObject *__pyx_v_mask); /*proto*/
+static PyMethodDef __pyx_mdef_11pycocotools_5_mask_5encode = {"encode", (PyCFunction)__pyx_pw_11pycocotools_5_mask_5encode, METH_O, 0};
+static PyObject *__pyx_pw_11pycocotools_5_mask_5encode(PyObject *__pyx_self, PyObject *__pyx_v_mask) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("encode (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_mask), __pyx_ptype_5numpy_ndarray, 1, "mask", 0))) __PYX_ERR(0, 137, __pyx_L1_error)
+  __pyx_r = __pyx_pf_11pycocotools_5_mask_4encode(__pyx_self, ((PyArrayObject *)__pyx_v_mask));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_11pycocotools_5_mask_4encode(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_mask) {
+  npy_intp __pyx_v_h;
+  npy_intp __pyx_v_w;
+  npy_intp __pyx_v_n;
+  struct __pyx_obj_11pycocotools_5_mask_RLEs *__pyx_v_Rs = 0;
+  PyObject *__pyx_v_objs = NULL;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_mask;
+  __Pyx_Buffer __pyx_pybuffer_mask;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  npy_intp __pyx_t_1;
+  npy_intp __pyx_t_2;
+  npy_intp __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  __Pyx_RefNannySetupContext("encode", 0);
+  __pyx_pybuffer_mask.pybuffer.buf = NULL;
+  __pyx_pybuffer_mask.refcount = 0;
+  __pyx_pybuffernd_mask.data = NULL;
+  __pyx_pybuffernd_mask.rcbuffer = &__pyx_pybuffer_mask;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_mask.rcbuffer->pybuffer, (PyObject*)__pyx_v_mask, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint8_t, PyBUF_FORMAT| PyBUF_F_CONTIGUOUS, 3, 0, __pyx_stack) == -1)) __PYX_ERR(0, 137, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_mask.diminfo[0].strides = __pyx_pybuffernd_mask.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_mask.diminfo[0].shape = __pyx_pybuffernd_mask.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_mask.diminfo[1].strides = __pyx_pybuffernd_mask.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_mask.diminfo[1].shape = __pyx_pybuffernd_mask.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_mask.diminfo[2].strides = __pyx_pybuffernd_mask.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_mask.diminfo[2].shape = __pyx_pybuffernd_mask.rcbuffer->pybuffer.shape[2];
+
+  /* "pycocotools/_mask.pyx":138
+ * # list of RLE string can be generated by RLEs member function
+ * def encode(np.ndarray[np.uint8_t, ndim=3, mode='fortran'] mask):
+ *     h, w, n = mask.shape[0], mask.shape[1], mask.shape[2]             # <<<<<<<<<<<<<<
+ *     cdef RLEs Rs = RLEs(n)
+ *     rleEncode(Rs._R,<byte*>mask.data,h,w,n)
+ */
+  __pyx_t_1 = (__pyx_v_mask->dimensions[0]);
+  __pyx_t_2 = (__pyx_v_mask->dimensions[1]);
+  __pyx_t_3 = (__pyx_v_mask->dimensions[2]);
+  __pyx_v_h = __pyx_t_1;
+  __pyx_v_w = __pyx_t_2;
+  __pyx_v_n = __pyx_t_3;
+
+  /* "pycocotools/_mask.pyx":139
+ * def encode(np.ndarray[np.uint8_t, ndim=3, mode='fortran'] mask):
+ *     h, w, n = mask.shape[0], mask.shape[1], mask.shape[2]
+ *     cdef RLEs Rs = RLEs(n)             # <<<<<<<<<<<<<<
+ *     rleEncode(Rs._R,<byte*>mask.data,h,w,n)
+ *     objs = _toString(Rs)
+ */
+  __pyx_t_4 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_n); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4);
+  __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_11pycocotools_5_mask_RLEs), __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_v_Rs = ((struct __pyx_obj_11pycocotools_5_mask_RLEs *)__pyx_t_4);
+  __pyx_t_4 = 0;
+
+  /* "pycocotools/_mask.pyx":140
+ *     h, w, n = mask.shape[0], mask.shape[1], mask.shape[2]
+ *     cdef RLEs Rs = RLEs(n)
+ *     rleEncode(Rs._R,<byte*>mask.data,h,w,n)             # <<<<<<<<<<<<<<
+ *     objs = _toString(Rs)
+ *     return objs
+ */
+  rleEncode(__pyx_v_Rs->_R, ((byte *)__pyx_v_mask->data), __pyx_v_h, __pyx_v_w, __pyx_v_n);
+
+  /* "pycocotools/_mask.pyx":141
+ *     cdef RLEs Rs = RLEs(n)
+ *     rleEncode(Rs._R,<byte*>mask.data,h,w,n)
+ *     objs = _toString(Rs)             # <<<<<<<<<<<<<<
+ *     return objs
+ * 
+ */
+  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_toString); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 141, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
+    if (likely(__pyx_t_6)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_6);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_5, function);
+    }
+  }
+  if (!__pyx_t_6) {
+    __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, ((PyObject *)__pyx_v_Rs)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 141, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_5)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_6, ((PyObject *)__pyx_v_Rs)};
+      __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 141, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_GOTREF(__pyx_t_4);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_6, ((PyObject *)__pyx_v_Rs)};
+      __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 141, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_GOTREF(__pyx_t_4);
+    } else
+    #endif
+    {
+      __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 141, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL;
+      __Pyx_INCREF(((PyObject *)__pyx_v_Rs));
+      __Pyx_GIVEREF(((PyObject *)__pyx_v_Rs));
+      PyTuple_SET_ITEM(__pyx_t_7, 0+1, ((PyObject *)__pyx_v_Rs));
+      __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 141, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_v_objs = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+  /* "pycocotools/_mask.pyx":142
+ *     rleEncode(Rs._R,<byte*>mask.data,h,w,n)
+ *     objs = _toString(Rs)
+ *     return objs             # <<<<<<<<<<<<<<
+ * 
+ * # decode mask from compressed list of RLE string or RLEs object
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_objs);
+  __pyx_r = __pyx_v_objs;
+  goto __pyx_L0;
+
+  /* "pycocotools/_mask.pyx":137
+ * # encode mask to RLEs objects
+ * # list of RLE string can be generated by RLEs member function
+ * def encode(np.ndarray[np.uint8_t, ndim=3, mode='fortran'] mask):             # <<<<<<<<<<<<<<
+ *     h, w, n = mask.shape[0], mask.shape[1], mask.shape[2]
+ *     cdef RLEs Rs = RLEs(n)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mask.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pycocotools._mask.encode", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mask.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_Rs);
+  __Pyx_XDECREF(__pyx_v_objs);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pycocotools/_mask.pyx":145
+ * 
+ * # decode mask from compressed list of RLE string or RLEs object
+ * def decode(rleObjs):             # <<<<<<<<<<<<<<
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     h, w, n = Rs._R[0].h, Rs._R[0].w, Rs._n
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11pycocotools_5_mask_7decode(PyObject *__pyx_self, PyObject *__pyx_v_rleObjs); /*proto*/
+static PyMethodDef __pyx_mdef_11pycocotools_5_mask_7decode = {"decode", (PyCFunction)__pyx_pw_11pycocotools_5_mask_7decode, METH_O, 0};
+static PyObject *__pyx_pw_11pycocotools_5_mask_7decode(PyObject *__pyx_self, PyObject *__pyx_v_rleObjs) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("decode (wrapper)", 0);
+  __pyx_r = __pyx_pf_11pycocotools_5_mask_6decode(__pyx_self, ((PyObject *)__pyx_v_rleObjs));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_11pycocotools_5_mask_6decode(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_rleObjs) {
+  struct __pyx_obj_11pycocotools_5_mask_RLEs *__pyx_v_Rs = 0;
+  siz __pyx_v_h;
+  siz __pyx_v_w;
+  siz __pyx_v_n;
+  struct __pyx_obj_11pycocotools_5_mask_Masks *__pyx_v_masks = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  siz __pyx_t_5;
+  siz __pyx_t_6;
+  siz __pyx_t_7;
+  __Pyx_RefNannySetupContext("decode", 0);
+
+  /* "pycocotools/_mask.pyx":146
+ * # decode mask from compressed list of RLE string or RLEs object
+ * def decode(rleObjs):
+ *     cdef RLEs Rs = _frString(rleObjs)             # <<<<<<<<<<<<<<
+ *     h, w, n = Rs._R[0].h, Rs._R[0].w, Rs._n
+ *     masks = Masks(h, w, n)
+ */
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_frString); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (!__pyx_t_3) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_rleObjs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_rleObjs};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_rleObjs};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL;
+      __Pyx_INCREF(__pyx_v_rleObjs);
+      __Pyx_GIVEREF(__pyx_v_rleObjs);
+      PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_rleObjs);
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_11pycocotools_5_mask_RLEs))))) __PYX_ERR(0, 146, __pyx_L1_error)
+  __pyx_v_Rs = ((struct __pyx_obj_11pycocotools_5_mask_RLEs *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":147
+ * def decode(rleObjs):
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     h, w, n = Rs._R[0].h, Rs._R[0].w, Rs._n             # <<<<<<<<<<<<<<
+ *     masks = Masks(h, w, n)
+ *     rleDecode(<RLE*>Rs._R, masks._mask, n);
+ */
+  __pyx_t_5 = (__pyx_v_Rs->_R[0]).h;
+  __pyx_t_6 = (__pyx_v_Rs->_R[0]).w;
+  __pyx_t_7 = __pyx_v_Rs->_n;
+  __pyx_v_h = __pyx_t_5;
+  __pyx_v_w = __pyx_t_6;
+  __pyx_v_n = __pyx_t_7;
+
+  /* "pycocotools/_mask.pyx":148
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     h, w, n = Rs._R[0].h, Rs._R[0].w, Rs._n
+ *     masks = Masks(h, w, n)             # <<<<<<<<<<<<<<
+ *     rleDecode(<RLE*>Rs._R, masks._mask, n);
+ *     return np.array(masks)
+ */
+  __pyx_t_1 = __Pyx_PyInt_From_siz(__pyx_v_h); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 148, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_From_siz(__pyx_v_w); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 148, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_PyInt_From_siz(__pyx_v_n); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 148, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 148, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_4);
+  __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_11pycocotools_5_mask_Masks), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 148, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_masks = ((struct __pyx_obj_11pycocotools_5_mask_Masks *)__pyx_t_4);
+  __pyx_t_4 = 0;
+
+  /* "pycocotools/_mask.pyx":149
+ *     h, w, n = Rs._R[0].h, Rs._R[0].w, Rs._n
+ *     masks = Masks(h, w, n)
+ *     rleDecode(<RLE*>Rs._R, masks._mask, n);             # <<<<<<<<<<<<<<
+ *     return np.array(masks)
+ * 
+ */
+  rleDecode(((RLE *)__pyx_v_Rs->_R), __pyx_v_masks->_mask, __pyx_v_n);
+
+  /* "pycocotools/_mask.pyx":150
+ *     masks = Masks(h, w, n)
+ *     rleDecode(<RLE*>Rs._R, masks._mask, n);
+ *     return np.array(masks)             # <<<<<<<<<<<<<<
+ * 
+ * def merge(rleObjs, intersect=0):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 150, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 150, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (!__pyx_t_3) {
+    __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_masks)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 150, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_3, ((PyObject *)__pyx_v_masks)};
+      __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 150, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_4);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_3, ((PyObject *)__pyx_v_masks)};
+      __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 150, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_4);
+    } else
+    #endif
+    {
+      __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 150, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3); __pyx_t_3 = NULL;
+      __Pyx_INCREF(((PyObject *)__pyx_v_masks));
+      __Pyx_GIVEREF(((PyObject *)__pyx_v_masks));
+      PyTuple_SET_ITEM(__pyx_t_1, 0+1, ((PyObject *)__pyx_v_masks));
+      __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 150, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
+  goto __pyx_L0;
+
+  /* "pycocotools/_mask.pyx":145
+ * 
+ * # decode mask from compressed list of RLE string or RLEs object
+ * def decode(rleObjs):             # <<<<<<<<<<<<<<
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     h, w, n = Rs._R[0].h, Rs._R[0].w, Rs._n
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("pycocotools._mask.decode", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_Rs);
+  __Pyx_XDECREF((PyObject *)__pyx_v_masks);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pycocotools/_mask.pyx":152
+ *     return np.array(masks)
+ * 
+ * def merge(rleObjs, intersect=0):             # <<<<<<<<<<<<<<
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     cdef RLEs R = RLEs(1)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11pycocotools_5_mask_9merge(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_11pycocotools_5_mask_9merge = {"merge", (PyCFunction)__pyx_pw_11pycocotools_5_mask_9merge, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_11pycocotools_5_mask_9merge(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_rleObjs = 0;
+  PyObject *__pyx_v_intersect = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("merge (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_rleObjs,&__pyx_n_s_intersect,0};
+    PyObject* values[2] = {0,0};
+    values[1] = ((PyObject *)__pyx_int_0);
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_rleObjs)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_intersect);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "merge") < 0)) __PYX_ERR(0, 152, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_rleObjs = values[0];
+    __pyx_v_intersect = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("merge", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 152, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pycocotools._mask.merge", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_11pycocotools_5_mask_8merge(__pyx_self, __pyx_v_rleObjs, __pyx_v_intersect);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_11pycocotools_5_mask_8merge(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_rleObjs, PyObject *__pyx_v_intersect) {
+  struct __pyx_obj_11pycocotools_5_mask_RLEs *__pyx_v_Rs = 0;
+  struct __pyx_obj_11pycocotools_5_mask_RLEs *__pyx_v_R = 0;
+  PyObject *__pyx_v_obj = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  __Pyx_RefNannySetupContext("merge", 0);
+
+  /* "pycocotools/_mask.pyx":153
+ * 
+ * def merge(rleObjs, intersect=0):
+ *     cdef RLEs Rs = _frString(rleObjs)             # <<<<<<<<<<<<<<
+ *     cdef RLEs R = RLEs(1)
+ *     rleMerge(<RLE*>Rs._R, <RLE*> R._R, <siz> Rs._n, intersect)
+ */
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_frString); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 153, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (!__pyx_t_3) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_rleObjs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_rleObjs};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_rleObjs};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 153, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL;
+      __Pyx_INCREF(__pyx_v_rleObjs);
+      __Pyx_GIVEREF(__pyx_v_rleObjs);
+      PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_rleObjs);
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_11pycocotools_5_mask_RLEs))))) __PYX_ERR(0, 153, __pyx_L1_error)
+  __pyx_v_Rs = ((struct __pyx_obj_11pycocotools_5_mask_RLEs *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":154
+ * def merge(rleObjs, intersect=0):
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     cdef RLEs R = RLEs(1)             # <<<<<<<<<<<<<<
+ *     rleMerge(<RLE*>Rs._R, <RLE*> R._R, <siz> Rs._n, intersect)
+ *     obj = _toString(R)[0]
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_11pycocotools_5_mask_RLEs), __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 154, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_R = ((struct __pyx_obj_11pycocotools_5_mask_RLEs *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":155
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     cdef RLEs R = RLEs(1)
+ *     rleMerge(<RLE*>Rs._R, <RLE*> R._R, <siz> Rs._n, intersect)             # <<<<<<<<<<<<<<
+ *     obj = _toString(R)[0]
+ *     return obj
+ */
+  __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_v_intersect); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 155, __pyx_L1_error)
+  rleMerge(((RLE *)__pyx_v_Rs->_R), ((RLE *)__pyx_v_R->_R), ((siz)__pyx_v_Rs->_n), __pyx_t_5);
+
+  /* "pycocotools/_mask.pyx":156
+ *     cdef RLEs R = RLEs(1)
+ *     rleMerge(<RLE*>Rs._R, <RLE*> R._R, <siz> Rs._n, intersect)
+ *     obj = _toString(R)[0]             # <<<<<<<<<<<<<<
+ *     return obj
+ * 
+ */
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_toString); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 156, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (!__pyx_t_4) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_R)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 156, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, ((PyObject *)__pyx_v_R)};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 156, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, ((PyObject *)__pyx_v_R)};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 156, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 156, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL;
+      __Pyx_INCREF(((PyObject *)__pyx_v_R));
+      __Pyx_GIVEREF(((PyObject *)__pyx_v_R));
+      PyTuple_SET_ITEM(__pyx_t_3, 0+1, ((PyObject *)__pyx_v_R));
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 156, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 156, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_obj = __pyx_t_2;
+  __pyx_t_2 = 0;
+
+  /* "pycocotools/_mask.pyx":157
+ *     rleMerge(<RLE*>Rs._R, <RLE*> R._R, <siz> Rs._n, intersect)
+ *     obj = _toString(R)[0]
+ *     return obj             # <<<<<<<<<<<<<<
+ * 
+ * def area(rleObjs):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_obj);
+  __pyx_r = __pyx_v_obj;
+  goto __pyx_L0;
+
+  /* "pycocotools/_mask.pyx":152
+ *     return np.array(masks)
+ * 
+ * def merge(rleObjs, intersect=0):             # <<<<<<<<<<<<<<
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     cdef RLEs R = RLEs(1)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("pycocotools._mask.merge", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_Rs);
+  __Pyx_XDECREF((PyObject *)__pyx_v_R);
+  __Pyx_XDECREF(__pyx_v_obj);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pycocotools/_mask.pyx":159
+ *     return obj
+ * 
+ * def area(rleObjs):             # <<<<<<<<<<<<<<
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     cdef uint* _a = <uint*> malloc(Rs._n* sizeof(uint))
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11pycocotools_5_mask_11area(PyObject *__pyx_self, PyObject *__pyx_v_rleObjs); /*proto*/
+static PyMethodDef __pyx_mdef_11pycocotools_5_mask_11area = {"area", (PyCFunction)__pyx_pw_11pycocotools_5_mask_11area, METH_O, 0};
+static PyObject *__pyx_pw_11pycocotools_5_mask_11area(PyObject *__pyx_self, PyObject *__pyx_v_rleObjs) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("area (wrapper)", 0);
+  __pyx_r = __pyx_pf_11pycocotools_5_mask_10area(__pyx_self, ((PyObject *)__pyx_v_rleObjs));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_11pycocotools_5_mask_10area(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_rleObjs) {
+  struct __pyx_obj_11pycocotools_5_mask_RLEs *__pyx_v_Rs = 0;
+  uint *__pyx_v__a;
+  npy_intp __pyx_v_shape[1];
+  PyObject *__pyx_v_a = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  __Pyx_RefNannySetupContext("area", 0);
+
+  /* "pycocotools/_mask.pyx":160
+ * 
+ * def area(rleObjs):
+ *     cdef RLEs Rs = _frString(rleObjs)             # <<<<<<<<<<<<<<
+ *     cdef uint* _a = <uint*> malloc(Rs._n* sizeof(uint))
+ *     rleArea(Rs._R, Rs._n, _a)
+ */
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_frString); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 160, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (!__pyx_t_3) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_rleObjs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_rleObjs};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_rleObjs};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 160, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL;
+      __Pyx_INCREF(__pyx_v_rleObjs);
+      __Pyx_GIVEREF(__pyx_v_rleObjs);
+      PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_rleObjs);
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_11pycocotools_5_mask_RLEs))))) __PYX_ERR(0, 160, __pyx_L1_error)
+  __pyx_v_Rs = ((struct __pyx_obj_11pycocotools_5_mask_RLEs *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":161
+ * def area(rleObjs):
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     cdef uint* _a = <uint*> malloc(Rs._n* sizeof(uint))             # <<<<<<<<<<<<<<
+ *     rleArea(Rs._R, Rs._n, _a)
+ *     cdef np.npy_intp shape[1]
+ */
+  __pyx_v__a = ((uint *)malloc((__pyx_v_Rs->_n * (sizeof(unsigned int)))));
+
+  /* "pycocotools/_mask.pyx":162
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     cdef uint* _a = <uint*> malloc(Rs._n* sizeof(uint))
+ *     rleArea(Rs._R, Rs._n, _a)             # <<<<<<<<<<<<<<
+ *     cdef np.npy_intp shape[1]
+ *     shape[0] = <np.npy_intp> Rs._n
+ */
+  rleArea(__pyx_v_Rs->_R, __pyx_v_Rs->_n, __pyx_v__a);
+
+  /* "pycocotools/_mask.pyx":164
+ *     rleArea(Rs._R, Rs._n, _a)
+ *     cdef np.npy_intp shape[1]
+ *     shape[0] = <np.npy_intp> Rs._n             # <<<<<<<<<<<<<<
+ *     a = np.array((Rs._n, ), dtype=np.uint8)
+ *     a = np.PyArray_SimpleNewFromData(1, shape, np.NPY_UINT32, _a)
+ */
+  (__pyx_v_shape[0]) = ((npy_intp)__pyx_v_Rs->_n);
+
+  /* "pycocotools/_mask.pyx":165
+ *     cdef np.npy_intp shape[1]
+ *     shape[0] = <np.npy_intp> Rs._n
+ *     a = np.array((Rs._n, ), dtype=np.uint8)             # <<<<<<<<<<<<<<
+ *     a = np.PyArray_SimpleNewFromData(1, shape, np.NPY_UINT32, _a)
+ *     PyArray_ENABLEFLAGS(a, np.NPY_OWNDATA)
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_array); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_siz(__pyx_v_Rs->_n); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4);
+  __pyx_t_4 = 0;
+  __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_uint8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 165, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_v_a = __pyx_t_5;
+  __pyx_t_5 = 0;
+
+  /* "pycocotools/_mask.pyx":166
+ *     shape[0] = <np.npy_intp> Rs._n
+ *     a = np.array((Rs._n, ), dtype=np.uint8)
+ *     a = np.PyArray_SimpleNewFromData(1, shape, np.NPY_UINT32, _a)             # <<<<<<<<<<<<<<
+ *     PyArray_ENABLEFLAGS(a, np.NPY_OWNDATA)
+ *     return a
+ */
+  __pyx_t_5 = PyArray_SimpleNewFromData(1, __pyx_v_shape, NPY_UINT32, __pyx_v__a); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF_SET(__pyx_v_a, __pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pycocotools/_mask.pyx":167
+ *     a = np.array((Rs._n, ), dtype=np.uint8)
+ *     a = np.PyArray_SimpleNewFromData(1, shape, np.NPY_UINT32, _a)
+ *     PyArray_ENABLEFLAGS(a, np.NPY_OWNDATA)             # <<<<<<<<<<<<<<
+ *     return a
+ * 
+ */
+  if (!(likely(((__pyx_v_a) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_a, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 167, __pyx_L1_error)
+  PyArray_ENABLEFLAGS(((PyArrayObject *)__pyx_v_a), NPY_OWNDATA);
+
+  /* "pycocotools/_mask.pyx":168
+ *     a = np.PyArray_SimpleNewFromData(1, shape, np.NPY_UINT32, _a)
+ *     PyArray_ENABLEFLAGS(a, np.NPY_OWNDATA)
+ *     return a             # <<<<<<<<<<<<<<
+ * 
+ * # iou computation. support function overload (RLEs-RLEs and bbox-bbox).
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_a);
+  __pyx_r = __pyx_v_a;
+  goto __pyx_L0;
+
+  /* "pycocotools/_mask.pyx":159
+ *     return obj
+ * 
+ * def area(rleObjs):             # <<<<<<<<<<<<<<
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     cdef uint* _a = <uint*> malloc(Rs._n* sizeof(uint))
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("pycocotools._mask.area", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_Rs);
+  __Pyx_XDECREF(__pyx_v_a);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pycocotools/_mask.pyx":171
+ * 
+ * # iou computation. support function overload (RLEs-RLEs and bbox-bbox).
+ * def iou( dt, gt, pyiscrowd ):             # <<<<<<<<<<<<<<
+ *     def _preproc(objs):
+ *         if len(objs) == 0:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11pycocotools_5_mask_13iou(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_11pycocotools_5_mask_13iou = {"iou", (PyCFunction)__pyx_pw_11pycocotools_5_mask_13iou, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_11pycocotools_5_mask_13iou(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_dt = 0;
+  PyObject *__pyx_v_gt = 0;
+  PyObject *__pyx_v_pyiscrowd = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("iou (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_dt,&__pyx_n_s_gt,&__pyx_n_s_pyiscrowd,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_dt)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_gt)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("iou", 1, 3, 3, 1); __PYX_ERR(0, 171, __pyx_L3_error)
+        }
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pyiscrowd)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("iou", 1, 3, 3, 2); __PYX_ERR(0, 171, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "iou") < 0)) __PYX_ERR(0, 171, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    }
+    __pyx_v_dt = values[0];
+    __pyx_v_gt = values[1];
+    __pyx_v_pyiscrowd = values[2];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("iou", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 171, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pycocotools._mask.iou", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_11pycocotools_5_mask_12iou(__pyx_self, __pyx_v_dt, __pyx_v_gt, __pyx_v_pyiscrowd);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pycocotools/_mask.pyx":172
+ * # iou computation. support function overload (RLEs-RLEs and bbox-bbox).
+ * def iou( dt, gt, pyiscrowd ):
+ *     def _preproc(objs):             # <<<<<<<<<<<<<<
+ *         if len(objs) == 0:
+ *             return objs
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11pycocotools_5_mask_3iou_1_preproc(PyObject *__pyx_self, PyObject *__pyx_v_objs); /*proto*/
+static PyMethodDef __pyx_mdef_11pycocotools_5_mask_3iou_1_preproc = {"_preproc", (PyCFunction)__pyx_pw_11pycocotools_5_mask_3iou_1_preproc, METH_O, 0};
+static PyObject *__pyx_pw_11pycocotools_5_mask_3iou_1_preproc(PyObject *__pyx_self, PyObject *__pyx_v_objs) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_preproc (wrapper)", 0);
+  __pyx_r = __pyx_pf_11pycocotools_5_mask_3iou__preproc(__pyx_self, ((PyObject *)__pyx_v_objs));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_11pycocotools_5_mask_3iou__preproc(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_objs) {
+  PyObject *__pyx_v_isbox = NULL;
+  PyObject *__pyx_v_isrle = NULL;
+  PyObject *__pyx_v_obj = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Py_ssize_t __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  int __pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *(*__pyx_t_11)(PyObject *);
+  PyObject *__pyx_t_12 = NULL;
+  Py_ssize_t __pyx_t_13;
+  PyObject *__pyx_t_14 = NULL;
+  __Pyx_RefNannySetupContext("_preproc", 0);
+  __Pyx_INCREF(__pyx_v_objs);
+
+  /* "pycocotools/_mask.pyx":173
+ * def iou( dt, gt, pyiscrowd ):
+ *     def _preproc(objs):
+ *         if len(objs) == 0:             # <<<<<<<<<<<<<<
+ *             return objs
+ *         if type(objs) == np.ndarray:
+ */
+  __pyx_t_1 = PyObject_Length(__pyx_v_objs); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(0, 173, __pyx_L1_error)
+  __pyx_t_2 = ((__pyx_t_1 == 0) != 0);
+  if (__pyx_t_2) {
+
+    /* "pycocotools/_mask.pyx":174
+ *     def _preproc(objs):
+ *         if len(objs) == 0:
+ *             return objs             # <<<<<<<<<<<<<<
+ *         if type(objs) == np.ndarray:
+ *             if len(objs.shape) == 1:
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(__pyx_v_objs);
+    __pyx_r = __pyx_v_objs;
+    goto __pyx_L0;
+
+    /* "pycocotools/_mask.pyx":173
+ * def iou( dt, gt, pyiscrowd ):
+ *     def _preproc(objs):
+ *         if len(objs) == 0:             # <<<<<<<<<<<<<<
+ *             return objs
+ *         if type(objs) == np.ndarray:
+ */
+  }
+
+  /* "pycocotools/_mask.pyx":175
+ *         if len(objs) == 0:
+ *             return objs
+ *         if type(objs) == np.ndarray:             # <<<<<<<<<<<<<<
+ *             if len(objs.shape) == 1:
+ *                 objs = objs.reshape((objs[0], 1))
+ */
+  __pyx_t_3 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_objs)), ((PyObject *)__pyx_ptype_5numpy_ndarray), Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 175, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 175, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (__pyx_t_2) {
+
+    /* "pycocotools/_mask.pyx":176
+ *             return objs
+ *         if type(objs) == np.ndarray:
+ *             if len(objs.shape) == 1:             # <<<<<<<<<<<<<<
+ *                 objs = objs.reshape((objs[0], 1))
+ *             # check if it's Nx4 bbox
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_objs, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 176, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_1 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(0, 176, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_2 = ((__pyx_t_1 == 1) != 0);
+    if (__pyx_t_2) {
+
+      /* "pycocotools/_mask.pyx":177
+ *         if type(objs) == np.ndarray:
+ *             if len(objs.shape) == 1:
+ *                 objs = objs.reshape((objs[0], 1))             # <<<<<<<<<<<<<<
+ *             # check if it's Nx4 bbox
+ *             if not len(objs.shape) == 2 or not objs.shape[1] == 4:
+ */
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_objs, __pyx_n_s_reshape); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 177, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_objs, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 177, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 177, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GIVEREF(__pyx_t_5);
+      PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5);
+      __Pyx_INCREF(__pyx_int_1);
+      __Pyx_GIVEREF(__pyx_int_1);
+      PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_int_1);
+      __pyx_t_5 = 0;
+      __pyx_t_5 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
+        if (likely(__pyx_t_5)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+          __Pyx_INCREF(__pyx_t_5);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_4, function);
+        }
+      }
+      if (!__pyx_t_5) {
+        __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 177, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_GOTREF(__pyx_t_3);
+      } else {
+        #if CYTHON_FAST_PYCALL
+        if (PyFunction_Check(__pyx_t_4)) {
+          PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_6};
+          __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 177, __pyx_L1_error)
+          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        } else
+        #endif
+        #if CYTHON_FAST_PYCCALL
+        if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+          PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_6};
+          __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 177, __pyx_L1_error)
+          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        } else
+        #endif
+        {
+          __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 177, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
+          __Pyx_GIVEREF(__pyx_t_6);
+          PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_6);
+          __pyx_t_6 = 0;
+          __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 177, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        }
+      }
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF_SET(__pyx_v_objs, __pyx_t_3);
+      __pyx_t_3 = 0;
+
+      /* "pycocotools/_mask.pyx":176
+ *             return objs
+ *         if type(objs) == np.ndarray:
+ *             if len(objs.shape) == 1:             # <<<<<<<<<<<<<<
+ *                 objs = objs.reshape((objs[0], 1))
+ *             # check if it's Nx4 bbox
+ */
+    }
+
+    /* "pycocotools/_mask.pyx":179
+ *                 objs = objs.reshape((objs[0], 1))
+ *             # check if it's Nx4 bbox
+ *             if not len(objs.shape) == 2 or not objs.shape[1] == 4:             # <<<<<<<<<<<<<<
+ *                 raise Exception('numpy ndarray input is only for *bounding boxes* and should have Nx4 dimension')
+ *             objs = objs.astype(np.double)
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_objs, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 179, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_1 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(0, 179, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_8 = ((!((__pyx_t_1 == 2) != 0)) != 0);
+    if (!__pyx_t_8) {
+    } else {
+      __pyx_t_2 = __pyx_t_8;
+      goto __pyx_L7_bool_binop_done;
+    }
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_objs, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 179, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_3, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 179, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_t_4, __pyx_int_4, 4, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 179, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 179, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_9 = ((!__pyx_t_8) != 0);
+    __pyx_t_2 = __pyx_t_9;
+    __pyx_L7_bool_binop_done:;
+    if (__pyx_t_2) {
+
+      /* "pycocotools/_mask.pyx":180
+ *             # check if it's Nx4 bbox
+ *             if not len(objs.shape) == 2 or not objs.shape[1] == 4:
+ *                 raise Exception('numpy ndarray input is only for *bounding boxes* and should have Nx4 dimension')             # <<<<<<<<<<<<<<
+ *             objs = objs.astype(np.double)
+ *         elif type(objs) == list:
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 180, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(0, 180, __pyx_L1_error)
+
+      /* "pycocotools/_mask.pyx":179
+ *                 objs = objs.reshape((objs[0], 1))
+ *             # check if it's Nx4 bbox
+ *             if not len(objs.shape) == 2 or not objs.shape[1] == 4:             # <<<<<<<<<<<<<<
+ *                 raise Exception('numpy ndarray input is only for *bounding boxes* and should have Nx4 dimension')
+ *             objs = objs.astype(np.double)
+ */
+    }
+
+    /* "pycocotools/_mask.pyx":181
+ *             if not len(objs.shape) == 2 or not objs.shape[1] == 4:
+ *                 raise Exception('numpy ndarray input is only for *bounding boxes* and should have Nx4 dimension')
+ *             objs = objs.astype(np.double)             # <<<<<<<<<<<<<<
+ *         elif type(objs) == list:
+ *             # check if list is in box format and convert it to np.ndarray
+ */
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_objs, __pyx_n_s_astype); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 181, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 181, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_double); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 181, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_7 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
+      if (likely(__pyx_t_7)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_7);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+      }
+    }
+    if (!__pyx_t_7) {
+      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 181, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_4)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6};
+        __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 181, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6};
+        __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 181, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      } else
+      #endif
+      {
+        __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 181, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_7); __pyx_t_7 = NULL;
+        __Pyx_GIVEREF(__pyx_t_6);
+        PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_6);
+        __pyx_t_6 = 0;
+        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 181, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF_SET(__pyx_v_objs, __pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "pycocotools/_mask.pyx":175
+ *         if len(objs) == 0:
+ *             return objs
+ *         if type(objs) == np.ndarray:             # <<<<<<<<<<<<<<
+ *             if len(objs.shape) == 1:
+ *                 objs = objs.reshape((objs[0], 1))
+ */
+    goto __pyx_L4;
+  }
+
+  /* "pycocotools/_mask.pyx":182
+ *                 raise Exception('numpy ndarray input is only for *bounding boxes* and should have Nx4 dimension')
+ *             objs = objs.astype(np.double)
+ *         elif type(objs) == list:             # <<<<<<<<<<<<<<
+ *             # check if list is in box format and convert it to np.ndarray
+ *             isbox = np.all(np.array([(len(obj)==4) and ((type(obj)==list) or (type(obj)==np.ndarray)) for obj in objs]))
+ */
+  __pyx_t_3 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_objs)), ((PyObject *)(&PyList_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 182, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 182, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (__pyx_t_2) {
+
+    /* "pycocotools/_mask.pyx":184
+ *         elif type(objs) == list:
+ *             # check if list is in box format and convert it to np.ndarray
+ *             isbox = np.all(np.array([(len(obj)==4) and ((type(obj)==list) or (type(obj)==np.ndarray)) for obj in objs]))             # <<<<<<<<<<<<<<
+ *             isrle = np.all(np.array([type(obj) == dict for obj in objs]))
+ *             if isbox:
+ */
+    __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 184, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_all); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 184, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 184, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_array); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 184, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 184, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    if (likely(PyList_CheckExact(__pyx_v_objs)) || PyTuple_CheckExact(__pyx_v_objs)) {
+      __pyx_t_10 = __pyx_v_objs; __Pyx_INCREF(__pyx_t_10); __pyx_t_1 = 0;
+      __pyx_t_11 = NULL;
+    } else {
+      __pyx_t_1 = -1; __pyx_t_10 = PyObject_GetIter(__pyx_v_objs); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 184, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_10);
+      __pyx_t_11 = Py_TYPE(__pyx_t_10)->tp_iternext; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 184, __pyx_L1_error)
+    }
+    for (;;) {
+      if (likely(!__pyx_t_11)) {
+        if (likely(PyList_CheckExact(__pyx_t_10))) {
+          if (__pyx_t_1 >= PyList_GET_SIZE(__pyx_t_10)) break;
+          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+          __pyx_t_12 = PyList_GET_ITEM(__pyx_t_10, __pyx_t_1); __Pyx_INCREF(__pyx_t_12); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(0, 184, __pyx_L1_error)
+          #else
+          __pyx_t_12 = PySequence_ITEM(__pyx_t_10, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 184, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_12);
+          #endif
+        } else {
+          if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_10)) break;
+          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+          __pyx_t_12 = PyTuple_GET_ITEM(__pyx_t_10, __pyx_t_1); __Pyx_INCREF(__pyx_t_12); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(0, 184, __pyx_L1_error)
+          #else
+          __pyx_t_12 = PySequence_ITEM(__pyx_t_10, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 184, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_12);
+          #endif
+        }
+      } else {
+        __pyx_t_12 = __pyx_t_11(__pyx_t_10);
+        if (unlikely(!__pyx_t_12)) {
+          PyObject* exc_type = PyErr_Occurred();
+          if (exc_type) {
+            if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+            else __PYX_ERR(0, 184, __pyx_L1_error)
+          }
+          break;
+        }
+        __Pyx_GOTREF(__pyx_t_12);
+      }
+      __Pyx_XDECREF_SET(__pyx_v_obj, __pyx_t_12);
+      __pyx_t_12 = 0;
+      __pyx_t_13 = PyObject_Length(__pyx_v_obj); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 184, __pyx_L1_error)
+      __pyx_t_2 = (__pyx_t_13 == 4);
+      if (__pyx_t_2) {
+      } else {
+        __pyx_t_14 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 184, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_14);
+        __pyx_t_12 = __pyx_t_14;
+        __pyx_t_14 = 0;
+        goto __pyx_L11_bool_binop_done;
+      }
+      __pyx_t_14 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_obj)), ((PyObject *)(&PyList_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_14); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 184, __pyx_L1_error)
+      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_14); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 184, __pyx_L1_error)
+      if (!__pyx_t_2) {
+        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+      } else {
+        __Pyx_INCREF(__pyx_t_14);
+        __pyx_t_12 = __pyx_t_14;
+        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+        goto __pyx_L11_bool_binop_done;
+      }
+      __pyx_t_14 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_obj)), ((PyObject *)__pyx_ptype_5numpy_ndarray), Py_EQ); __Pyx_XGOTREF(__pyx_t_14); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 184, __pyx_L1_error)
+      __Pyx_INCREF(__pyx_t_14);
+      __pyx_t_12 = __pyx_t_14;
+      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+      __pyx_L11_bool_binop_done:;
+      if (unlikely(__Pyx_ListComp_Append(__pyx_t_6, (PyObject*)__pyx_t_12))) __PYX_ERR(0, 184, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+    __pyx_t_10 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
+      __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_7);
+      if (likely(__pyx_t_10)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+        __Pyx_INCREF(__pyx_t_10);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_7, function);
+      }
+    }
+    if (!__pyx_t_10) {
+      __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 184, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_GOTREF(__pyx_t_4);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_7)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_10, __pyx_t_6};
+        __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 184, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_10, __pyx_t_6};
+        __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 184, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      } else
+      #endif
+      {
+        __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 184, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_12);
+        __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_10); __pyx_t_10 = NULL;
+        __Pyx_GIVEREF(__pyx_t_6);
+        PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_6);
+        __pyx_t_6 = 0;
+        __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 184, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_7 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
+      if (likely(__pyx_t_7)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+        __Pyx_INCREF(__pyx_t_7);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+      }
+    }
+    if (!__pyx_t_7) {
+      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 184, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_5)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_4};
+        __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 184, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_4};
+        __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 184, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      } else
+      #endif
+      {
+        __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 184, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_12);
+        __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_7); __pyx_t_7 = NULL;
+        __Pyx_GIVEREF(__pyx_t_4);
+        PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_4);
+        __pyx_t_4 = 0;
+        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_12, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 184, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_v_isbox = __pyx_t_3;
+    __pyx_t_3 = 0;
+
+    /* "pycocotools/_mask.pyx":185
+ *             # check if list is in box format and convert it to np.ndarray
+ *             isbox = np.all(np.array([(len(obj)==4) and ((type(obj)==list) or (type(obj)==np.ndarray)) for obj in objs]))
+ *             isrle = np.all(np.array([type(obj) == dict for obj in objs]))             # <<<<<<<<<<<<<<
+ *             if isbox:
+ *                 objs = np.array(objs, dtype=np.double)
+ */
+    __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 185, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_all); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 185, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_12);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 185, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_array); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 185, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 185, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (likely(PyList_CheckExact(__pyx_v_objs)) || PyTuple_CheckExact(__pyx_v_objs)) {
+      __pyx_t_6 = __pyx_v_objs; __Pyx_INCREF(__pyx_t_6); __pyx_t_1 = 0;
+      __pyx_t_11 = NULL;
+    } else {
+      __pyx_t_1 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_v_objs); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 185, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_t_11 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 185, __pyx_L1_error)
+    }
+    for (;;) {
+      if (likely(!__pyx_t_11)) {
+        if (likely(PyList_CheckExact(__pyx_t_6))) {
+          if (__pyx_t_1 >= PyList_GET_SIZE(__pyx_t_6)) break;
+          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+          __pyx_t_10 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_1); __Pyx_INCREF(__pyx_t_10); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(0, 185, __pyx_L1_error)
+          #else
+          __pyx_t_10 = PySequence_ITEM(__pyx_t_6, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 185, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_10);
+          #endif
+        } else {
+          if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_6)) break;
+          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+          __pyx_t_10 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_1); __Pyx_INCREF(__pyx_t_10); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(0, 185, __pyx_L1_error)
+          #else
+          __pyx_t_10 = PySequence_ITEM(__pyx_t_6, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 185, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_10);
+          #endif
+        }
+      } else {
+        __pyx_t_10 = __pyx_t_11(__pyx_t_6);
+        if (unlikely(!__pyx_t_10)) {
+          PyObject* exc_type = PyErr_Occurred();
+          if (exc_type) {
+            if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+            else __PYX_ERR(0, 185, __pyx_L1_error)
+          }
+          break;
+        }
+        __Pyx_GOTREF(__pyx_t_10);
+      }
+      __Pyx_XDECREF_SET(__pyx_v_obj, __pyx_t_10);
+      __pyx_t_10 = 0;
+      __pyx_t_10 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_obj)), ((PyObject *)(&PyDict_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 185, __pyx_L1_error)
+      if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_10))) __PYX_ERR(0, 185, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_t_6 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
+      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7);
+      if (likely(__pyx_t_6)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+        __Pyx_INCREF(__pyx_t_6);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_7, function);
+      }
+    }
+    if (!__pyx_t_6) {
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 185, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_5);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_7)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_4};
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 185, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_4};
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 185, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      } else
+      #endif
+      {
+        __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 185, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_6); __pyx_t_6 = NULL;
+        __Pyx_GIVEREF(__pyx_t_4);
+        PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_4);
+        __pyx_t_4 = 0;
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 185, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_7 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_12))) {
+      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_12);
+      if (likely(__pyx_t_7)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12);
+        __Pyx_INCREF(__pyx_t_7);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_12, function);
+      }
+    }
+    if (!__pyx_t_7) {
+      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 185, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_12)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_5};
+        __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_12, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 185, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_12)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_5};
+        __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_12, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 185, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      } else
+      #endif
+      {
+        __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 185, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_7); __pyx_t_7 = NULL;
+        __Pyx_GIVEREF(__pyx_t_5);
+        PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_5);
+        __pyx_t_5 = 0;
+        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 185, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+    __pyx_v_isrle = __pyx_t_3;
+    __pyx_t_3 = 0;
+
+    /* "pycocotools/_mask.pyx":186
+ *             isbox = np.all(np.array([(len(obj)==4) and ((type(obj)==list) or (type(obj)==np.ndarray)) for obj in objs]))
+ *             isrle = np.all(np.array([type(obj) == dict for obj in objs]))
+ *             if isbox:             # <<<<<<<<<<<<<<
+ *                 objs = np.array(objs, dtype=np.double)
+ *                 if len(objs.shape) == 1:
+ */
+    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_isbox); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 186, __pyx_L1_error)
+    if (__pyx_t_2) {
+
+      /* "pycocotools/_mask.pyx":187
+ *             isrle = np.all(np.array([type(obj) == dict for obj in objs]))
+ *             if isbox:
+ *                 objs = np.array(objs, dtype=np.double)             # <<<<<<<<<<<<<<
+ *                 if len(objs.shape) == 1:
+ *                     objs = objs.reshape((1,objs.shape[0]))
+ */
+      __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 187, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 187, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_12);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 187, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_INCREF(__pyx_v_objs);
+      __Pyx_GIVEREF(__pyx_v_objs);
+      PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_objs);
+      __pyx_t_10 = PyDict_New(); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 187, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_10);
+      __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 187, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_double); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 187, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(0, 187, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_3, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 187, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_DECREF_SET(__pyx_v_objs, __pyx_t_7);
+      __pyx_t_7 = 0;
+
+      /* "pycocotools/_mask.pyx":188
+ *             if isbox:
+ *                 objs = np.array(objs, dtype=np.double)
+ *                 if len(objs.shape) == 1:             # <<<<<<<<<<<<<<
+ *                     objs = objs.reshape((1,objs.shape[0]))
+ *             elif isrle:
+ */
+      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_objs, __pyx_n_s_shape); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 188, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __pyx_t_1 = PyObject_Length(__pyx_t_7); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(0, 188, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __pyx_t_2 = ((__pyx_t_1 == 1) != 0);
+      if (__pyx_t_2) {
+
+        /* "pycocotools/_mask.pyx":189
+ *                 objs = np.array(objs, dtype=np.double)
+ *                 if len(objs.shape) == 1:
+ *                     objs = objs.reshape((1,objs.shape[0]))             # <<<<<<<<<<<<<<
+ *             elif isrle:
+ *                 objs = _frString(objs)
+ */
+        __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_objs, __pyx_n_s_reshape); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 189, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_objs, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 189, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 189, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_12);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 189, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_INCREF(__pyx_int_1);
+        __Pyx_GIVEREF(__pyx_int_1);
+        PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_int_1);
+        __Pyx_GIVEREF(__pyx_t_12);
+        PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_12);
+        __pyx_t_12 = 0;
+        __pyx_t_12 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) {
+          __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_10);
+          if (likely(__pyx_t_12)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
+            __Pyx_INCREF(__pyx_t_12);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_10, function);
+          }
+        }
+        if (!__pyx_t_12) {
+          __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 189, __pyx_L1_error)
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+          __Pyx_GOTREF(__pyx_t_7);
+        } else {
+          #if CYTHON_FAST_PYCALL
+          if (PyFunction_Check(__pyx_t_10)) {
+            PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_t_3};
+            __pyx_t_7 = __Pyx_PyFunction_FastCall(__pyx_t_10, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 189, __pyx_L1_error)
+            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+            __Pyx_GOTREF(__pyx_t_7);
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+          } else
+          #endif
+          #if CYTHON_FAST_PYCCALL
+          if (__Pyx_PyFastCFunction_Check(__pyx_t_10)) {
+            PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_t_3};
+            __pyx_t_7 = __Pyx_PyCFunction_FastCall(__pyx_t_10, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 189, __pyx_L1_error)
+            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+            __Pyx_GOTREF(__pyx_t_7);
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+          } else
+          #endif
+          {
+            __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 189, __pyx_L1_error)
+            __Pyx_GOTREF(__pyx_t_5);
+            __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_12); __pyx_t_12 = NULL;
+            __Pyx_GIVEREF(__pyx_t_3);
+            PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_3);
+            __pyx_t_3 = 0;
+            __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_5, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 189, __pyx_L1_error)
+            __Pyx_GOTREF(__pyx_t_7);
+            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+          }
+        }
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        __Pyx_DECREF_SET(__pyx_v_objs, __pyx_t_7);
+        __pyx_t_7 = 0;
+
+        /* "pycocotools/_mask.pyx":188
+ *             if isbox:
+ *                 objs = np.array(objs, dtype=np.double)
+ *                 if len(objs.shape) == 1:             # <<<<<<<<<<<<<<
+ *                     objs = objs.reshape((1,objs.shape[0]))
+ *             elif isrle:
+ */
+      }
+
+      /* "pycocotools/_mask.pyx":186
+ *             isbox = np.all(np.array([(len(obj)==4) and ((type(obj)==list) or (type(obj)==np.ndarray)) for obj in objs]))
+ *             isrle = np.all(np.array([type(obj) == dict for obj in objs]))
+ *             if isbox:             # <<<<<<<<<<<<<<
+ *                 objs = np.array(objs, dtype=np.double)
+ *                 if len(objs.shape) == 1:
+ */
+      goto __pyx_L16;
+    }
+
+    /* "pycocotools/_mask.pyx":190
+ *                 if len(objs.shape) == 1:
+ *                     objs = objs.reshape((1,objs.shape[0]))
+ *             elif isrle:             # <<<<<<<<<<<<<<
+ *                 objs = _frString(objs)
+ *             else:
+ */
+    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_isrle); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 190, __pyx_L1_error)
+    if (__pyx_t_2) {
+
+      /* "pycocotools/_mask.pyx":191
+ *                     objs = objs.reshape((1,objs.shape[0]))
+ *             elif isrle:
+ *                 objs = _frString(objs)             # <<<<<<<<<<<<<<
+ *             else:
+ *                 raise Exception('list input can be bounding box (Nx4) or RLEs ([RLE])')
+ */
+      __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_frString); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 191, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_10);
+      __pyx_t_5 = NULL;
+      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_10))) {
+        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_10);
+        if (likely(__pyx_t_5)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
+          __Pyx_INCREF(__pyx_t_5);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_10, function);
+        }
+      }
+      if (!__pyx_t_5) {
+        __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_objs); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 191, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_7);
+      } else {
+        #if CYTHON_FAST_PYCALL
+        if (PyFunction_Check(__pyx_t_10)) {
+          PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_v_objs};
+          __pyx_t_7 = __Pyx_PyFunction_FastCall(__pyx_t_10, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 191, __pyx_L1_error)
+          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+          __Pyx_GOTREF(__pyx_t_7);
+        } else
+        #endif
+        #if CYTHON_FAST_PYCCALL
+        if (__Pyx_PyFastCFunction_Check(__pyx_t_10)) {
+          PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_v_objs};
+          __pyx_t_7 = __Pyx_PyCFunction_FastCall(__pyx_t_10, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 191, __pyx_L1_error)
+          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+          __Pyx_GOTREF(__pyx_t_7);
+        } else
+        #endif
+        {
+          __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 191, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5); __pyx_t_5 = NULL;
+          __Pyx_INCREF(__pyx_v_objs);
+          __Pyx_GIVEREF(__pyx_v_objs);
+          PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_v_objs);
+          __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_3, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 191, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_7);
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        }
+      }
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_DECREF_SET(__pyx_v_objs, __pyx_t_7);
+      __pyx_t_7 = 0;
+
+      /* "pycocotools/_mask.pyx":190
+ *                 if len(objs.shape) == 1:
+ *                     objs = objs.reshape((1,objs.shape[0]))
+ *             elif isrle:             # <<<<<<<<<<<<<<
+ *                 objs = _frString(objs)
+ *             else:
+ */
+      goto __pyx_L16;
+    }
+
+    /* "pycocotools/_mask.pyx":193
+ *                 objs = _frString(objs)
+ *             else:
+ *                 raise Exception('list input can be bounding box (Nx4) or RLEs ([RLE])')             # <<<<<<<<<<<<<<
+ *         else:
+ *             raise Exception('unrecognized type.  The following type: RLEs (rle), np.ndarray (box), and list (box) are supported.')
+ */
+    /*else*/ {
+      __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 193, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_Raise(__pyx_t_7, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __PYX_ERR(0, 193, __pyx_L1_error)
+    }
+    __pyx_L16:;
+
+    /* "pycocotools/_mask.pyx":182
+ *                 raise Exception('numpy ndarray input is only for *bounding boxes* and should have Nx4 dimension')
+ *             objs = objs.astype(np.double)
+ *         elif type(objs) == list:             # <<<<<<<<<<<<<<
+ *             # check if list is in box format and convert it to np.ndarray
+ *             isbox = np.all(np.array([(len(obj)==4) and ((type(obj)==list) or (type(obj)==np.ndarray)) for obj in objs]))
+ */
+    goto __pyx_L4;
+  }
+
+  /* "pycocotools/_mask.pyx":195
+ *                 raise Exception('list input can be bounding box (Nx4) or RLEs ([RLE])')
+ *         else:
+ *             raise Exception('unrecognized type.  The following type: RLEs (rle), np.ndarray (box), and list (box) are supported.')             # <<<<<<<<<<<<<<
+ *         return objs
+ *     def _rleIou(RLEs dt, RLEs gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t,  ndim=1] _iou):
+ */
+  /*else*/ {
+    __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 195, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_Raise(__pyx_t_7, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __PYX_ERR(0, 195, __pyx_L1_error)
+  }
+  __pyx_L4:;
+
+  /* "pycocotools/_mask.pyx":196
+ *         else:
+ *             raise Exception('unrecognized type.  The following type: RLEs (rle), np.ndarray (box), and list (box) are supported.')
+ *         return objs             # <<<<<<<<<<<<<<
+ *     def _rleIou(RLEs dt, RLEs gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t,  ndim=1] _iou):
+ *         rleIou( <RLE*> dt._R, <RLE*> gt._R, m, n, <byte*> iscrowd.data, <double*> _iou.data )
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_objs);
+  __pyx_r = __pyx_v_objs;
+  goto __pyx_L0;
+
+  /* "pycocotools/_mask.pyx":172
+ * # iou computation. support function overload (RLEs-RLEs and bbox-bbox).
+ * def iou( dt, gt, pyiscrowd ):
+ *     def _preproc(objs):             # <<<<<<<<<<<<<<
+ *         if len(objs) == 0:
+ *             return objs
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_XDECREF(__pyx_t_14);
+  __Pyx_AddTraceback("pycocotools._mask.iou._preproc", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_isbox);
+  __Pyx_XDECREF(__pyx_v_isrle);
+  __Pyx_XDECREF(__pyx_v_obj);
+  __Pyx_XDECREF(__pyx_v_objs);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pycocotools/_mask.pyx":197
+ *             raise Exception('unrecognized type.  The following type: RLEs (rle), np.ndarray (box), and list (box) are supported.')
+ *         return objs
+ *     def _rleIou(RLEs dt, RLEs gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t,  ndim=1] _iou):             # <<<<<<<<<<<<<<
+ *         rleIou( <RLE*> dt._R, <RLE*> gt._R, m, n, <byte*> iscrowd.data, <double*> _iou.data )
+ *     def _bbIou(np.ndarray[np.double_t, ndim=2] dt, np.ndarray[np.double_t, ndim=2] gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t, ndim=1] _iou):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11pycocotools_5_mask_3iou_3_rleIou(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_11pycocotools_5_mask_3iou_3_rleIou = {"_rleIou", (PyCFunction)__pyx_pw_11pycocotools_5_mask_3iou_3_rleIou, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_11pycocotools_5_mask_3iou_3_rleIou(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_11pycocotools_5_mask_RLEs *__pyx_v_dt = 0;
+  struct __pyx_obj_11pycocotools_5_mask_RLEs *__pyx_v_gt = 0;
+  PyArrayObject *__pyx_v_iscrowd = 0;
+  siz __pyx_v_m;
+  siz __pyx_v_n;
+  PyArrayObject *__pyx_v__iou = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_rleIou (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_dt,&__pyx_n_s_gt,&__pyx_n_s_iscrowd,&__pyx_n_s_m,&__pyx_n_s_n,&__pyx_n_s_iou,0};
+    PyObject* values[6] = {0,0,0,0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_dt)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_gt)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("_rleIou", 1, 6, 6, 1); __PYX_ERR(0, 197, __pyx_L3_error)
+        }
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_iscrowd)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("_rleIou", 1, 6, 6, 2); __PYX_ERR(0, 197, __pyx_L3_error)
+        }
+        case  3:
+        if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_m)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("_rleIou", 1, 6, 6, 3); __PYX_ERR(0, 197, __pyx_L3_error)
+        }
+        case  4:
+        if (likely((values[4] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_n)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("_rleIou", 1, 6, 6, 4); __PYX_ERR(0, 197, __pyx_L3_error)
+        }
+        case  5:
+        if (likely((values[5] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_iou)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("_rleIou", 1, 6, 6, 5); __PYX_ERR(0, 197, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_rleIou") < 0)) __PYX_ERR(0, 197, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 6) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+      values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+    }
+    __pyx_v_dt = ((struct __pyx_obj_11pycocotools_5_mask_RLEs *)values[0]);
+    __pyx_v_gt = ((struct __pyx_obj_11pycocotools_5_mask_RLEs *)values[1]);
+    __pyx_v_iscrowd = ((PyArrayObject *)values[2]);
+    __pyx_v_m = __Pyx_PyInt_As_siz(values[3]); if (unlikely((__pyx_v_m == ((siz)-1)) && PyErr_Occurred())) __PYX_ERR(0, 197, __pyx_L3_error)
+    __pyx_v_n = __Pyx_PyInt_As_siz(values[4]); if (unlikely((__pyx_v_n == ((siz)-1)) && PyErr_Occurred())) __PYX_ERR(0, 197, __pyx_L3_error)
+    __pyx_v__iou = ((PyArrayObject *)values[5]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("_rleIou", 1, 6, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 197, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pycocotools._mask.iou._rleIou", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), __pyx_ptype_11pycocotools_5_mask_RLEs, 1, "dt", 0))) __PYX_ERR(0, 197, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_gt), __pyx_ptype_11pycocotools_5_mask_RLEs, 1, "gt", 0))) __PYX_ERR(0, 197, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_iscrowd), __pyx_ptype_5numpy_ndarray, 1, "iscrowd", 0))) __PYX_ERR(0, 197, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v__iou), __pyx_ptype_5numpy_ndarray, 1, "_iou", 0))) __PYX_ERR(0, 197, __pyx_L1_error)
+  __pyx_r = __pyx_pf_11pycocotools_5_mask_3iou_2_rleIou(__pyx_self, __pyx_v_dt, __pyx_v_gt, __pyx_v_iscrowd, __pyx_v_m, __pyx_v_n, __pyx_v__iou);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_11pycocotools_5_mask_3iou_2_rleIou(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_11pycocotools_5_mask_RLEs *__pyx_v_dt, struct __pyx_obj_11pycocotools_5_mask_RLEs *__pyx_v_gt, PyArrayObject *__pyx_v_iscrowd, siz __pyx_v_m, siz __pyx_v_n, PyArrayObject *__pyx_v__iou) {
+  __Pyx_LocalBuf_ND __pyx_pybuffernd__iou;
+  __Pyx_Buffer __pyx_pybuffer__iou;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_iscrowd;
+  __Pyx_Buffer __pyx_pybuffer_iscrowd;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_rleIou", 0);
+  __pyx_pybuffer_iscrowd.pybuffer.buf = NULL;
+  __pyx_pybuffer_iscrowd.refcount = 0;
+  __pyx_pybuffernd_iscrowd.data = NULL;
+  __pyx_pybuffernd_iscrowd.rcbuffer = &__pyx_pybuffer_iscrowd;
+  __pyx_pybuffer__iou.pybuffer.buf = NULL;
+  __pyx_pybuffer__iou.refcount = 0;
+  __pyx_pybuffernd__iou.data = NULL;
+  __pyx_pybuffernd__iou.rcbuffer = &__pyx_pybuffer__iou;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_iscrowd.rcbuffer->pybuffer, (PyObject*)__pyx_v_iscrowd, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint8_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 197, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_iscrowd.diminfo[0].strides = __pyx_pybuffernd_iscrowd.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_iscrowd.diminfo[0].shape = __pyx_pybuffernd_iscrowd.rcbuffer->pybuffer.shape[0];
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd__iou.rcbuffer->pybuffer, (PyObject*)__pyx_v__iou, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 197, __pyx_L1_error)
+  }
+  __pyx_pybuffernd__iou.diminfo[0].strides = __pyx_pybuffernd__iou.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd__iou.diminfo[0].shape = __pyx_pybuffernd__iou.rcbuffer->pybuffer.shape[0];
+
+  /* "pycocotools/_mask.pyx":198
+ *         return objs
+ *     def _rleIou(RLEs dt, RLEs gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t,  ndim=1] _iou):
+ *         rleIou( <RLE*> dt._R, <RLE*> gt._R, m, n, <byte*> iscrowd.data, <double*> _iou.data )             # <<<<<<<<<<<<<<
+ *     def _bbIou(np.ndarray[np.double_t, ndim=2] dt, np.ndarray[np.double_t, ndim=2] gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t, ndim=1] _iou):
+ *         bbIou( <BB> dt.data, <BB> gt.data, m, n, <byte*> iscrowd.data, <double*>_iou.data )
+ */
+  rleIou(((RLE *)__pyx_v_dt->_R), ((RLE *)__pyx_v_gt->_R), __pyx_v_m, __pyx_v_n, ((byte *)__pyx_v_iscrowd->data), ((double *)__pyx_v__iou->data));
+
+  /* "pycocotools/_mask.pyx":197
+ *             raise Exception('unrecognized type.  The following type: RLEs (rle), np.ndarray (box), and list (box) are supported.')
+ *         return objs
+ *     def _rleIou(RLEs dt, RLEs gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t,  ndim=1] _iou):             # <<<<<<<<<<<<<<
+ *         rleIou( <RLE*> dt._R, <RLE*> gt._R, m, n, <byte*> iscrowd.data, <double*> _iou.data )
+ *     def _bbIou(np.ndarray[np.double_t, ndim=2] dt, np.ndarray[np.double_t, ndim=2] gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t, ndim=1] _iou):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd__iou.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_iscrowd.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pycocotools._mask.iou._rleIou", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd__iou.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_iscrowd.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pycocotools/_mask.pyx":199
+ *     def _rleIou(RLEs dt, RLEs gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t,  ndim=1] _iou):
+ *         rleIou( <RLE*> dt._R, <RLE*> gt._R, m, n, <byte*> iscrowd.data, <double*> _iou.data )
+ *     def _bbIou(np.ndarray[np.double_t, ndim=2] dt, np.ndarray[np.double_t, ndim=2] gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t, ndim=1] _iou):             # <<<<<<<<<<<<<<
+ *         bbIou( <BB> dt.data, <BB> gt.data, m, n, <byte*> iscrowd.data, <double*>_iou.data )
+ *     def _len(obj):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11pycocotools_5_mask_3iou_5_bbIou(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_11pycocotools_5_mask_3iou_5_bbIou = {"_bbIou", (PyCFunction)__pyx_pw_11pycocotools_5_mask_3iou_5_bbIou, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_11pycocotools_5_mask_3iou_5_bbIou(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyArrayObject *__pyx_v_dt = 0;
+  PyArrayObject *__pyx_v_gt = 0;
+  PyArrayObject *__pyx_v_iscrowd = 0;
+  siz __pyx_v_m;
+  siz __pyx_v_n;
+  PyArrayObject *__pyx_v__iou = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_bbIou (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_dt,&__pyx_n_s_gt,&__pyx_n_s_iscrowd,&__pyx_n_s_m,&__pyx_n_s_n,&__pyx_n_s_iou,0};
+    PyObject* values[6] = {0,0,0,0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_dt)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_gt)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("_bbIou", 1, 6, 6, 1); __PYX_ERR(0, 199, __pyx_L3_error)
+        }
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_iscrowd)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("_bbIou", 1, 6, 6, 2); __PYX_ERR(0, 199, __pyx_L3_error)
+        }
+        case  3:
+        if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_m)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("_bbIou", 1, 6, 6, 3); __PYX_ERR(0, 199, __pyx_L3_error)
+        }
+        case  4:
+        if (likely((values[4] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_n)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("_bbIou", 1, 6, 6, 4); __PYX_ERR(0, 199, __pyx_L3_error)
+        }
+        case  5:
+        if (likely((values[5] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_iou)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("_bbIou", 1, 6, 6, 5); __PYX_ERR(0, 199, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_bbIou") < 0)) __PYX_ERR(0, 199, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 6) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+      values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+    }
+    __pyx_v_dt = ((PyArrayObject *)values[0]);
+    __pyx_v_gt = ((PyArrayObject *)values[1]);
+    __pyx_v_iscrowd = ((PyArrayObject *)values[2]);
+    __pyx_v_m = __Pyx_PyInt_As_siz(values[3]); if (unlikely((__pyx_v_m == ((siz)-1)) && PyErr_Occurred())) __PYX_ERR(0, 199, __pyx_L3_error)
+    __pyx_v_n = __Pyx_PyInt_As_siz(values[4]); if (unlikely((__pyx_v_n == ((siz)-1)) && PyErr_Occurred())) __PYX_ERR(0, 199, __pyx_L3_error)
+    __pyx_v__iou = ((PyArrayObject *)values[5]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("_bbIou", 1, 6, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 199, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pycocotools._mask.iou._bbIou", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), __pyx_ptype_5numpy_ndarray, 1, "dt", 0))) __PYX_ERR(0, 199, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_gt), __pyx_ptype_5numpy_ndarray, 1, "gt", 0))) __PYX_ERR(0, 199, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_iscrowd), __pyx_ptype_5numpy_ndarray, 1, "iscrowd", 0))) __PYX_ERR(0, 199, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v__iou), __pyx_ptype_5numpy_ndarray, 1, "_iou", 0))) __PYX_ERR(0, 199, __pyx_L1_error)
+  __pyx_r = __pyx_pf_11pycocotools_5_mask_3iou_4_bbIou(__pyx_self, __pyx_v_dt, __pyx_v_gt, __pyx_v_iscrowd, __pyx_v_m, __pyx_v_n, __pyx_v__iou);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_11pycocotools_5_mask_3iou_4_bbIou(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_dt, PyArrayObject *__pyx_v_gt, PyArrayObject *__pyx_v_iscrowd, siz __pyx_v_m, siz __pyx_v_n, PyArrayObject *__pyx_v__iou) {
+  __Pyx_LocalBuf_ND __pyx_pybuffernd__iou;
+  __Pyx_Buffer __pyx_pybuffer__iou;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_dt;
+  __Pyx_Buffer __pyx_pybuffer_dt;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_gt;
+  __Pyx_Buffer __pyx_pybuffer_gt;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_iscrowd;
+  __Pyx_Buffer __pyx_pybuffer_iscrowd;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_bbIou", 0);
+  __pyx_pybuffer_dt.pybuffer.buf = NULL;
+  __pyx_pybuffer_dt.refcount = 0;
+  __pyx_pybuffernd_dt.data = NULL;
+  __pyx_pybuffernd_dt.rcbuffer = &__pyx_pybuffer_dt;
+  __pyx_pybuffer_gt.pybuffer.buf = NULL;
+  __pyx_pybuffer_gt.refcount = 0;
+  __pyx_pybuffernd_gt.data = NULL;
+  __pyx_pybuffernd_gt.rcbuffer = &__pyx_pybuffer_gt;
+  __pyx_pybuffer_iscrowd.pybuffer.buf = NULL;
+  __pyx_pybuffer_iscrowd.refcount = 0;
+  __pyx_pybuffernd_iscrowd.data = NULL;
+  __pyx_pybuffernd_iscrowd.rcbuffer = &__pyx_pybuffer_iscrowd;
+  __pyx_pybuffer__iou.pybuffer.buf = NULL;
+  __pyx_pybuffer__iou.refcount = 0;
+  __pyx_pybuffernd__iou.data = NULL;
+  __pyx_pybuffernd__iou.rcbuffer = &__pyx_pybuffer__iou;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_dt.rcbuffer->pybuffer, (PyObject*)__pyx_v_dt, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 199, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_dt.diminfo[0].strides = __pyx_pybuffernd_dt.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_dt.diminfo[0].shape = __pyx_pybuffernd_dt.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_dt.diminfo[1].strides = __pyx_pybuffernd_dt.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_dt.diminfo[1].shape = __pyx_pybuffernd_dt.rcbuffer->pybuffer.shape[1];
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_gt.rcbuffer->pybuffer, (PyObject*)__pyx_v_gt, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 199, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_gt.diminfo[0].strides = __pyx_pybuffernd_gt.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_gt.diminfo[0].shape = __pyx_pybuffernd_gt.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_gt.diminfo[1].strides = __pyx_pybuffernd_gt.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_gt.diminfo[1].shape = __pyx_pybuffernd_gt.rcbuffer->pybuffer.shape[1];
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_iscrowd.rcbuffer->pybuffer, (PyObject*)__pyx_v_iscrowd, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint8_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 199, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_iscrowd.diminfo[0].strides = __pyx_pybuffernd_iscrowd.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_iscrowd.diminfo[0].shape = __pyx_pybuffernd_iscrowd.rcbuffer->pybuffer.shape[0];
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd__iou.rcbuffer->pybuffer, (PyObject*)__pyx_v__iou, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 199, __pyx_L1_error)
+  }
+  __pyx_pybuffernd__iou.diminfo[0].strides = __pyx_pybuffernd__iou.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd__iou.diminfo[0].shape = __pyx_pybuffernd__iou.rcbuffer->pybuffer.shape[0];
+
+  /* "pycocotools/_mask.pyx":200
+ *         rleIou( <RLE*> dt._R, <RLE*> gt._R, m, n, <byte*> iscrowd.data, <double*> _iou.data )
+ *     def _bbIou(np.ndarray[np.double_t, ndim=2] dt, np.ndarray[np.double_t, ndim=2] gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t, ndim=1] _iou):
+ *         bbIou( <BB> dt.data, <BB> gt.data, m, n, <byte*> iscrowd.data, <double*>_iou.data )             # <<<<<<<<<<<<<<
+ *     def _len(obj):
+ *         cdef siz N = 0
+ */
+  bbIou(((BB)__pyx_v_dt->data), ((BB)__pyx_v_gt->data), __pyx_v_m, __pyx_v_n, ((byte *)__pyx_v_iscrowd->data), ((double *)__pyx_v__iou->data));
+
+  /* "pycocotools/_mask.pyx":199
+ *     def _rleIou(RLEs dt, RLEs gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t,  ndim=1] _iou):
+ *         rleIou( <RLE*> dt._R, <RLE*> gt._R, m, n, <byte*> iscrowd.data, <double*> _iou.data )
+ *     def _bbIou(np.ndarray[np.double_t, ndim=2] dt, np.ndarray[np.double_t, ndim=2] gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t, ndim=1] _iou):             # <<<<<<<<<<<<<<
+ *         bbIou( <BB> dt.data, <BB> gt.data, m, n, <byte*> iscrowd.data, <double*>_iou.data )
+ *     def _len(obj):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd__iou.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_dt.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_gt.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_iscrowd.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pycocotools._mask.iou._bbIou", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd__iou.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_dt.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_gt.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_iscrowd.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pycocotools/_mask.pyx":201
+ *     def _bbIou(np.ndarray[np.double_t, ndim=2] dt, np.ndarray[np.double_t, ndim=2] gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t, ndim=1] _iou):
+ *         bbIou( <BB> dt.data, <BB> gt.data, m, n, <byte*> iscrowd.data, <double*>_iou.data )
+ *     def _len(obj):             # <<<<<<<<<<<<<<
+ *         cdef siz N = 0
+ *         if type(obj) == RLEs:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11pycocotools_5_mask_3iou_7_len(PyObject *__pyx_self, PyObject *__pyx_v_obj); /*proto*/
+static PyMethodDef __pyx_mdef_11pycocotools_5_mask_3iou_7_len = {"_len", (PyCFunction)__pyx_pw_11pycocotools_5_mask_3iou_7_len, METH_O, 0};
+static PyObject *__pyx_pw_11pycocotools_5_mask_3iou_7_len(PyObject *__pyx_self, PyObject *__pyx_v_obj) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_len (wrapper)", 0);
+  __pyx_r = __pyx_pf_11pycocotools_5_mask_3iou_6_len(__pyx_self, ((PyObject *)__pyx_v_obj));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_11pycocotools_5_mask_3iou_6_len(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_obj) {
+  siz __pyx_v_N;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  siz __pyx_t_3;
+  Py_ssize_t __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  __Pyx_RefNannySetupContext("_len", 0);
+
+  /* "pycocotools/_mask.pyx":202
+ *         bbIou( <BB> dt.data, <BB> gt.data, m, n, <byte*> iscrowd.data, <double*>_iou.data )
+ *     def _len(obj):
+ *         cdef siz N = 0             # <<<<<<<<<<<<<<
+ *         if type(obj) == RLEs:
+ *             N = obj.n
+ */
+  __pyx_v_N = 0;
+
+  /* "pycocotools/_mask.pyx":203
+ *     def _len(obj):
+ *         cdef siz N = 0
+ *         if type(obj) == RLEs:             # <<<<<<<<<<<<<<
+ *             N = obj.n
+ *         elif len(obj)==0:
+ */
+  __pyx_t_1 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_obj)), ((PyObject *)__pyx_ptype_11pycocotools_5_mask_RLEs), Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 203, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 203, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (__pyx_t_2) {
+
+    /* "pycocotools/_mask.pyx":204
+ *         cdef siz N = 0
+ *         if type(obj) == RLEs:
+ *             N = obj.n             # <<<<<<<<<<<<<<
+ *         elif len(obj)==0:
+ *             pass
+ */
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_n); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 204, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_3 = __Pyx_PyInt_As_siz(__pyx_t_1); if (unlikely((__pyx_t_3 == ((siz)-1)) && PyErr_Occurred())) __PYX_ERR(0, 204, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_v_N = __pyx_t_3;
+
+    /* "pycocotools/_mask.pyx":203
+ *     def _len(obj):
+ *         cdef siz N = 0
+ *         if type(obj) == RLEs:             # <<<<<<<<<<<<<<
+ *             N = obj.n
+ *         elif len(obj)==0:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pycocotools/_mask.pyx":205
+ *         if type(obj) == RLEs:
+ *             N = obj.n
+ *         elif len(obj)==0:             # <<<<<<<<<<<<<<
+ *             pass
+ *         elif type(obj) == np.ndarray:
+ */
+  __pyx_t_4 = PyObject_Length(__pyx_v_obj); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(0, 205, __pyx_L1_error)
+  __pyx_t_2 = ((__pyx_t_4 == 0) != 0);
+  if (__pyx_t_2) {
+    goto __pyx_L3;
+  }
+
+  /* "pycocotools/_mask.pyx":207
+ *         elif len(obj)==0:
+ *             pass
+ *         elif type(obj) == np.ndarray:             # <<<<<<<<<<<<<<
+ *             N = obj.shape[0]
+ *         return N
+ */
+  __pyx_t_1 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_obj)), ((PyObject *)__pyx_ptype_5numpy_ndarray), Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 207, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 207, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (__pyx_t_2) {
+
+    /* "pycocotools/_mask.pyx":208
+ *             pass
+ *         elif type(obj) == np.ndarray:
+ *             N = obj.shape[0]             # <<<<<<<<<<<<<<
+ *         return N
+ *     # convert iscrowd to numpy array
+ */
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_obj, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 208, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 208, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_3 = __Pyx_PyInt_As_siz(__pyx_t_5); if (unlikely((__pyx_t_3 == ((siz)-1)) && PyErr_Occurred())) __PYX_ERR(0, 208, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_v_N = __pyx_t_3;
+
+    /* "pycocotools/_mask.pyx":207
+ *         elif len(obj)==0:
+ *             pass
+ *         elif type(obj) == np.ndarray:             # <<<<<<<<<<<<<<
+ *             N = obj.shape[0]
+ *         return N
+ */
+  }
+  __pyx_L3:;
+
+  /* "pycocotools/_mask.pyx":209
+ *         elif type(obj) == np.ndarray:
+ *             N = obj.shape[0]
+ *         return N             # <<<<<<<<<<<<<<
+ *     # convert iscrowd to numpy array
+ *     cdef np.ndarray[np.uint8_t, ndim=1] iscrowd = np.array(pyiscrowd, dtype=np.uint8)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_5 = __Pyx_PyInt_From_siz(__pyx_v_N); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "pycocotools/_mask.pyx":201
+ *     def _bbIou(np.ndarray[np.double_t, ndim=2] dt, np.ndarray[np.double_t, ndim=2] gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t, ndim=1] _iou):
+ *         bbIou( <BB> dt.data, <BB> gt.data, m, n, <byte*> iscrowd.data, <double*>_iou.data )
+ *     def _len(obj):             # <<<<<<<<<<<<<<
+ *         cdef siz N = 0
+ *         if type(obj) == RLEs:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("pycocotools._mask.iou._len", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pycocotools/_mask.pyx":171
+ * 
+ * # iou computation. support function overload (RLEs-RLEs and bbox-bbox).
+ * def iou( dt, gt, pyiscrowd ):             # <<<<<<<<<<<<<<
+ *     def _preproc(objs):
+ *         if len(objs) == 0:
+ */
+
+static PyObject *__pyx_pf_11pycocotools_5_mask_12iou(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_dt, PyObject *__pyx_v_gt, PyObject *__pyx_v_pyiscrowd) {
+  PyObject *__pyx_v__preproc = 0;
+  PyObject *__pyx_v__rleIou = 0;
+  PyObject *__pyx_v__bbIou = 0;
+  PyObject *__pyx_v__len = 0;
+  PyArrayObject *__pyx_v_iscrowd = 0;
+  siz __pyx_v_m;
+  siz __pyx_v_n;
+  double *__pyx_v__iou;
+  npy_intp __pyx_v_shape[1];
+  PyObject *__pyx_v__iouFun = NULL;
+  PyObject *__pyx_v_iou = NULL;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_iscrowd;
+  __Pyx_Buffer __pyx_pybuffer_iscrowd;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyArrayObject *__pyx_t_6 = NULL;
+  siz __pyx_t_7;
+  int __pyx_t_8;
+  int __pyx_t_9;
+  int __pyx_t_10;
+  PyObject *__pyx_t_11 = NULL;
+  __Pyx_RefNannySetupContext("iou", 0);
+  __Pyx_INCREF(__pyx_v_dt);
+  __Pyx_INCREF(__pyx_v_gt);
+  __pyx_pybuffer_iscrowd.pybuffer.buf = NULL;
+  __pyx_pybuffer_iscrowd.refcount = 0;
+  __pyx_pybuffernd_iscrowd.data = NULL;
+  __pyx_pybuffernd_iscrowd.rcbuffer = &__pyx_pybuffer_iscrowd;
+
+  /* "pycocotools/_mask.pyx":172
+ * # iou computation. support function overload (RLEs-RLEs and bbox-bbox).
+ * def iou( dt, gt, pyiscrowd ):
+ *     def _preproc(objs):             # <<<<<<<<<<<<<<
+ *         if len(objs) == 0:
+ *             return objs
+ */
+  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_11pycocotools_5_mask_3iou_1_preproc, 0, __pyx_n_s_iou_locals__preproc, NULL, __pyx_n_s_pycocotools__mask, __pyx_d, ((PyObject *)__pyx_codeobj__8)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v__preproc = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":197
+ *             raise Exception('unrecognized type.  The following type: RLEs (rle), np.ndarray (box), and list (box) are supported.')
+ *         return objs
+ *     def _rleIou(RLEs dt, RLEs gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t,  ndim=1] _iou):             # <<<<<<<<<<<<<<
+ *         rleIou( <RLE*> dt._R, <RLE*> gt._R, m, n, <byte*> iscrowd.data, <double*> _iou.data )
+ *     def _bbIou(np.ndarray[np.double_t, ndim=2] dt, np.ndarray[np.double_t, ndim=2] gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t, ndim=1] _iou):
+ */
+  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_11pycocotools_5_mask_3iou_3_rleIou, 0, __pyx_n_s_iou_locals__rleIou, NULL, __pyx_n_s_pycocotools__mask, __pyx_d, ((PyObject *)__pyx_codeobj__10)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v__rleIou = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":199
+ *     def _rleIou(RLEs dt, RLEs gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t,  ndim=1] _iou):
+ *         rleIou( <RLE*> dt._R, <RLE*> gt._R, m, n, <byte*> iscrowd.data, <double*> _iou.data )
+ *     def _bbIou(np.ndarray[np.double_t, ndim=2] dt, np.ndarray[np.double_t, ndim=2] gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t, ndim=1] _iou):             # <<<<<<<<<<<<<<
+ *         bbIou( <BB> dt.data, <BB> gt.data, m, n, <byte*> iscrowd.data, <double*>_iou.data )
+ *     def _len(obj):
+ */
+  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_11pycocotools_5_mask_3iou_5_bbIou, 0, __pyx_n_s_iou_locals__bbIou, NULL, __pyx_n_s_pycocotools__mask, __pyx_d, ((PyObject *)__pyx_codeobj__12)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v__bbIou = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":201
+ *     def _bbIou(np.ndarray[np.double_t, ndim=2] dt, np.ndarray[np.double_t, ndim=2] gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t, ndim=1] _iou):
+ *         bbIou( <BB> dt.data, <BB> gt.data, m, n, <byte*> iscrowd.data, <double*>_iou.data )
+ *     def _len(obj):             # <<<<<<<<<<<<<<
+ *         cdef siz N = 0
+ *         if type(obj) == RLEs:
+ */
+  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_11pycocotools_5_mask_3iou_7_len, 0, __pyx_n_s_iou_locals__len, NULL, __pyx_n_s_pycocotools__mask, __pyx_d, ((PyObject *)__pyx_codeobj__14)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 201, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v__len = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":211
+ *         return N
+ *     # convert iscrowd to numpy array
+ *     cdef np.ndarray[np.uint8_t, ndim=1] iscrowd = np.array(pyiscrowd, dtype=np.uint8)             # <<<<<<<<<<<<<<
+ *     # simple type checking
+ *     cdef siz m, n
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 211, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_array); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 211, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 211, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(__pyx_v_pyiscrowd);
+  __Pyx_GIVEREF(__pyx_v_pyiscrowd);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_pyiscrowd);
+  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 211, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 211, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_uint8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 211, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 211, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 211, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 211, __pyx_L1_error)
+  __pyx_t_6 = ((PyArrayObject *)__pyx_t_5);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_iscrowd.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint8_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_iscrowd = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_iscrowd.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 211, __pyx_L1_error)
+    } else {__pyx_pybuffernd_iscrowd.diminfo[0].strides = __pyx_pybuffernd_iscrowd.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_iscrowd.diminfo[0].shape = __pyx_pybuffernd_iscrowd.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_6 = 0;
+  __pyx_v_iscrowd = ((PyArrayObject *)__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pycocotools/_mask.pyx":214
+ *     # simple type checking
+ *     cdef siz m, n
+ *     dt = _preproc(dt)             # <<<<<<<<<<<<<<
+ *     gt = _preproc(gt)
+ *     m = _len(dt)
+ */
+  __pyx_t_5 = __pyx_pf_11pycocotools_5_mask_3iou__preproc(__pyx_v__preproc, __pyx_v_dt); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 214, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF_SET(__pyx_v_dt, __pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pycocotools/_mask.pyx":215
+ *     cdef siz m, n
+ *     dt = _preproc(dt)
+ *     gt = _preproc(gt)             # <<<<<<<<<<<<<<
+ *     m = _len(dt)
+ *     n = _len(gt)
+ */
+  __pyx_t_5 = __pyx_pf_11pycocotools_5_mask_3iou__preproc(__pyx_v__preproc, __pyx_v_gt); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 215, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF_SET(__pyx_v_gt, __pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pycocotools/_mask.pyx":216
+ *     dt = _preproc(dt)
+ *     gt = _preproc(gt)
+ *     m = _len(dt)             # <<<<<<<<<<<<<<
+ *     n = _len(gt)
+ *     if m == 0 or n == 0:
+ */
+  __pyx_t_5 = __pyx_pf_11pycocotools_5_mask_3iou_6_len(__pyx_v__len, __pyx_v_dt); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 216, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_7 = __Pyx_PyInt_As_siz(__pyx_t_5); if (unlikely((__pyx_t_7 == ((siz)-1)) && PyErr_Occurred())) __PYX_ERR(0, 216, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_v_m = __pyx_t_7;
+
+  /* "pycocotools/_mask.pyx":217
+ *     gt = _preproc(gt)
+ *     m = _len(dt)
+ *     n = _len(gt)             # <<<<<<<<<<<<<<
+ *     if m == 0 or n == 0:
+ *         return []
+ */
+  __pyx_t_5 = __pyx_pf_11pycocotools_5_mask_3iou_6_len(__pyx_v__len, __pyx_v_gt); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 217, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_7 = __Pyx_PyInt_As_siz(__pyx_t_5); if (unlikely((__pyx_t_7 == ((siz)-1)) && PyErr_Occurred())) __PYX_ERR(0, 217, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_v_n = __pyx_t_7;
+
+  /* "pycocotools/_mask.pyx":218
+ *     m = _len(dt)
+ *     n = _len(gt)
+ *     if m == 0 or n == 0:             # <<<<<<<<<<<<<<
+ *         return []
+ *     if not type(dt) == type(gt):
+ */
+  __pyx_t_9 = ((__pyx_v_m == 0) != 0);
+  if (!__pyx_t_9) {
+  } else {
+    __pyx_t_8 = __pyx_t_9;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_9 = ((__pyx_v_n == 0) != 0);
+  __pyx_t_8 = __pyx_t_9;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_8) {
+
+    /* "pycocotools/_mask.pyx":219
+ *     n = _len(gt)
+ *     if m == 0 or n == 0:
+ *         return []             # <<<<<<<<<<<<<<
+ *     if not type(dt) == type(gt):
+ *         raise Exception('The dt and gt should have the same data type, either RLEs, list or np.ndarray')
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 219, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_r = __pyx_t_5;
+    __pyx_t_5 = 0;
+    goto __pyx_L0;
+
+    /* "pycocotools/_mask.pyx":218
+ *     m = _len(dt)
+ *     n = _len(gt)
+ *     if m == 0 or n == 0:             # <<<<<<<<<<<<<<
+ *         return []
+ *     if not type(dt) == type(gt):
+ */
+  }
+
+  /* "pycocotools/_mask.pyx":220
+ *     if m == 0 or n == 0:
+ *         return []
+ *     if not type(dt) == type(gt):             # <<<<<<<<<<<<<<
+ *         raise Exception('The dt and gt should have the same data type, either RLEs, list or np.ndarray')
+ * 
+ */
+  __pyx_t_5 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_dt)), ((PyObject *)Py_TYPE(__pyx_v_gt)), Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 220, __pyx_L1_error)
+  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 220, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_9 = ((!__pyx_t_8) != 0);
+  if (__pyx_t_9) {
+
+    /* "pycocotools/_mask.pyx":221
+ *         return []
+ *     if not type(dt) == type(gt):
+ *         raise Exception('The dt and gt should have the same data type, either RLEs, list or np.ndarray')             # <<<<<<<<<<<<<<
+ * 
+ *     # define local variables
+ */
+    __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 221, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __PYX_ERR(0, 221, __pyx_L1_error)
+
+    /* "pycocotools/_mask.pyx":220
+ *     if m == 0 or n == 0:
+ *         return []
+ *     if not type(dt) == type(gt):             # <<<<<<<<<<<<<<
+ *         raise Exception('The dt and gt should have the same data type, either RLEs, list or np.ndarray')
+ * 
+ */
+  }
+
+  /* "pycocotools/_mask.pyx":224
+ * 
+ *     # define local variables
+ *     cdef double* _iou = <double*> 0             # <<<<<<<<<<<<<<
+ *     cdef np.npy_intp shape[1]
+ *     # check type and assign iou function
+ */
+  __pyx_v__iou = ((double *)0);
+
+  /* "pycocotools/_mask.pyx":227
+ *     cdef np.npy_intp shape[1]
+ *     # check type and assign iou function
+ *     if type(dt) == RLEs:             # <<<<<<<<<<<<<<
+ *         _iouFun = _rleIou
+ *     elif type(dt) == np.ndarray:
+ */
+  __pyx_t_5 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_dt)), ((PyObject *)__pyx_ptype_11pycocotools_5_mask_RLEs), Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 227, __pyx_L1_error)
+  __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 227, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (__pyx_t_9) {
+
+    /* "pycocotools/_mask.pyx":228
+ *     # check type and assign iou function
+ *     if type(dt) == RLEs:
+ *         _iouFun = _rleIou             # <<<<<<<<<<<<<<
+ *     elif type(dt) == np.ndarray:
+ *         _iouFun = _bbIou
+ */
+    __Pyx_INCREF(__pyx_v__rleIou);
+    __pyx_v__iouFun = __pyx_v__rleIou;
+
+    /* "pycocotools/_mask.pyx":227
+ *     cdef np.npy_intp shape[1]
+ *     # check type and assign iou function
+ *     if type(dt) == RLEs:             # <<<<<<<<<<<<<<
+ *         _iouFun = _rleIou
+ *     elif type(dt) == np.ndarray:
+ */
+    goto __pyx_L7;
+  }
+
+  /* "pycocotools/_mask.pyx":229
+ *     if type(dt) == RLEs:
+ *         _iouFun = _rleIou
+ *     elif type(dt) == np.ndarray:             # <<<<<<<<<<<<<<
+ *         _iouFun = _bbIou
+ *     else:
+ */
+  __pyx_t_5 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_dt)), ((PyObject *)__pyx_ptype_5numpy_ndarray), Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 229, __pyx_L1_error)
+  __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 229, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (__pyx_t_9) {
+
+    /* "pycocotools/_mask.pyx":230
+ *         _iouFun = _rleIou
+ *     elif type(dt) == np.ndarray:
+ *         _iouFun = _bbIou             # <<<<<<<<<<<<<<
+ *     else:
+ *         raise Exception('input data type not allowed.')
+ */
+    __Pyx_INCREF(__pyx_v__bbIou);
+    __pyx_v__iouFun = __pyx_v__bbIou;
+
+    /* "pycocotools/_mask.pyx":229
+ *     if type(dt) == RLEs:
+ *         _iouFun = _rleIou
+ *     elif type(dt) == np.ndarray:             # <<<<<<<<<<<<<<
+ *         _iouFun = _bbIou
+ *     else:
+ */
+    goto __pyx_L7;
+  }
+
+  /* "pycocotools/_mask.pyx":232
+ *         _iouFun = _bbIou
+ *     else:
+ *         raise Exception('input data type not allowed.')             # <<<<<<<<<<<<<<
+ *     _iou = <double*> malloc(m*n* sizeof(double))
+ *     iou = np.zeros((m*n, ), dtype=np.double)
+ */
+  /*else*/ {
+    __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 232, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __PYX_ERR(0, 232, __pyx_L1_error)
+  }
+  __pyx_L7:;
+
+  /* "pycocotools/_mask.pyx":233
+ *     else:
+ *         raise Exception('input data type not allowed.')
+ *     _iou = <double*> malloc(m*n* sizeof(double))             # <<<<<<<<<<<<<<
+ *     iou = np.zeros((m*n, ), dtype=np.double)
+ *     shape[0] = <np.npy_intp> m*n
+ */
+  __pyx_v__iou = ((double *)malloc(((__pyx_v_m * __pyx_v_n) * (sizeof(double)))));
+
+  /* "pycocotools/_mask.pyx":234
+ *         raise Exception('input data type not allowed.')
+ *     _iou = <double*> malloc(m*n* sizeof(double))
+ *     iou = np.zeros((m*n, ), dtype=np.double)             # <<<<<<<<<<<<<<
+ *     shape[0] = <np.npy_intp> m*n
+ *     iou = np.PyArray_SimpleNewFromData(1, shape, np.NPY_DOUBLE, _iou)
+ */
+  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyInt_From_siz((__pyx_v_m * __pyx_v_n)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_5);
+  __pyx_t_5 = 0;
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_double); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_iou = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+  /* "pycocotools/_mask.pyx":235
+ *     _iou = <double*> malloc(m*n* sizeof(double))
+ *     iou = np.zeros((m*n, ), dtype=np.double)
+ *     shape[0] = <np.npy_intp> m*n             # <<<<<<<<<<<<<<
+ *     iou = np.PyArray_SimpleNewFromData(1, shape, np.NPY_DOUBLE, _iou)
+ *     PyArray_ENABLEFLAGS(iou, np.NPY_OWNDATA)
+ */
+  (__pyx_v_shape[0]) = (((npy_intp)__pyx_v_m) * __pyx_v_n);
+
+  /* "pycocotools/_mask.pyx":236
+ *     iou = np.zeros((m*n, ), dtype=np.double)
+ *     shape[0] = <np.npy_intp> m*n
+ *     iou = np.PyArray_SimpleNewFromData(1, shape, np.NPY_DOUBLE, _iou)             # <<<<<<<<<<<<<<
+ *     PyArray_ENABLEFLAGS(iou, np.NPY_OWNDATA)
+ *     _iouFun(dt, gt, iscrowd, m, n, iou)
+ */
+  __pyx_t_4 = PyArray_SimpleNewFromData(1, __pyx_v_shape, NPY_DOUBLE, __pyx_v__iou); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 236, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF_SET(__pyx_v_iou, __pyx_t_4);
+  __pyx_t_4 = 0;
+
+  /* "pycocotools/_mask.pyx":237
+ *     shape[0] = <np.npy_intp> m*n
+ *     iou = np.PyArray_SimpleNewFromData(1, shape, np.NPY_DOUBLE, _iou)
+ *     PyArray_ENABLEFLAGS(iou, np.NPY_OWNDATA)             # <<<<<<<<<<<<<<
+ *     _iouFun(dt, gt, iscrowd, m, n, iou)
+ *     return iou.reshape((m,n), order='F')
+ */
+  if (!(likely(((__pyx_v_iou) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_iou, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 237, __pyx_L1_error)
+  PyArray_ENABLEFLAGS(((PyArrayObject *)__pyx_v_iou), NPY_OWNDATA);
+
+  /* "pycocotools/_mask.pyx":238
+ *     iou = np.PyArray_SimpleNewFromData(1, shape, np.NPY_DOUBLE, _iou)
+ *     PyArray_ENABLEFLAGS(iou, np.NPY_OWNDATA)
+ *     _iouFun(dt, gt, iscrowd, m, n, iou)             # <<<<<<<<<<<<<<
+ *     return iou.reshape((m,n), order='F')
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyInt_From_siz(__pyx_v_m); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_5 = __Pyx_PyInt_From_siz(__pyx_v_n); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_INCREF(__pyx_v__iouFun);
+  __pyx_t_3 = __pyx_v__iouFun; __pyx_t_2 = NULL;
+  __pyx_t_10 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+      __pyx_t_10 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_3)) {
+    PyObject *__pyx_temp[7] = {__pyx_t_2, __pyx_v_dt, __pyx_v_gt, ((PyObject *)__pyx_v_iscrowd), __pyx_t_1, __pyx_t_5, __pyx_v_iou};
+    __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_10, 6+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 238, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+    PyObject *__pyx_temp[7] = {__pyx_t_2, __pyx_v_dt, __pyx_v_gt, ((PyObject *)__pyx_v_iscrowd), __pyx_t_1, __pyx_t_5, __pyx_v_iou};
+    __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_10, 6+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 238, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_11 = PyTuple_New(6+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 238, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_11);
+    if (__pyx_t_2) {
+      __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_2); __pyx_t_2 = NULL;
+    }
+    __Pyx_INCREF(__pyx_v_dt);
+    __Pyx_GIVEREF(__pyx_v_dt);
+    PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_v_dt);
+    __Pyx_INCREF(__pyx_v_gt);
+    __Pyx_GIVEREF(__pyx_v_gt);
+    PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_v_gt);
+    __Pyx_INCREF(((PyObject *)__pyx_v_iscrowd));
+    __Pyx_GIVEREF(((PyObject *)__pyx_v_iscrowd));
+    PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_10, ((PyObject *)__pyx_v_iscrowd));
+    __Pyx_GIVEREF(__pyx_t_1);
+    PyTuple_SET_ITEM(__pyx_t_11, 3+__pyx_t_10, __pyx_t_1);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_11, 4+__pyx_t_10, __pyx_t_5);
+    __Pyx_INCREF(__pyx_v_iou);
+    __Pyx_GIVEREF(__pyx_v_iou);
+    PyTuple_SET_ITEM(__pyx_t_11, 5+__pyx_t_10, __pyx_v_iou);
+    __pyx_t_1 = 0;
+    __pyx_t_5 = 0;
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_11, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 238, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "pycocotools/_mask.pyx":239
+ *     PyArray_ENABLEFLAGS(iou, np.NPY_OWNDATA)
+ *     _iouFun(dt, gt, iscrowd, m, n, iou)
+ *     return iou.reshape((m,n), order='F')             # <<<<<<<<<<<<<<
+ * 
+ * def toBbox( rleObjs ):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_iou, __pyx_n_s_reshape); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 239, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = __Pyx_PyInt_From_siz(__pyx_v_m); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 239, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_11 = __Pyx_PyInt_From_siz(__pyx_v_n); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 239, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_11);
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 239, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_11);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_11);
+  __pyx_t_3 = 0;
+  __pyx_t_11 = 0;
+  __pyx_t_11 = PyTuple_New(1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 239, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_11);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_5);
+  __pyx_t_5 = 0;
+  __pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 239, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_order, __pyx_n_s_F) < 0) __PYX_ERR(0, 239, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_11, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 239, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pycocotools/_mask.pyx":171
+ * 
+ * # iou computation. support function overload (RLEs-RLEs and bbox-bbox).
+ * def iou( dt, gt, pyiscrowd ):             # <<<<<<<<<<<<<<
+ *     def _preproc(objs):
+ *         if len(objs) == 0:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_11);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_iscrowd.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pycocotools._mask.iou", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_iscrowd.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF(__pyx_v__preproc);
+  __Pyx_XDECREF(__pyx_v__rleIou);
+  __Pyx_XDECREF(__pyx_v__bbIou);
+  __Pyx_XDECREF(__pyx_v__len);
+  __Pyx_XDECREF((PyObject *)__pyx_v_iscrowd);
+  __Pyx_XDECREF(__pyx_v__iouFun);
+  __Pyx_XDECREF(__pyx_v_iou);
+  __Pyx_XDECREF(__pyx_v_dt);
+  __Pyx_XDECREF(__pyx_v_gt);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pycocotools/_mask.pyx":241
+ *     return iou.reshape((m,n), order='F')
+ * 
+ * def toBbox( rleObjs ):             # <<<<<<<<<<<<<<
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     cdef siz n = Rs.n
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11pycocotools_5_mask_15toBbox(PyObject *__pyx_self, PyObject *__pyx_v_rleObjs); /*proto*/
+static PyMethodDef __pyx_mdef_11pycocotools_5_mask_15toBbox = {"toBbox", (PyCFunction)__pyx_pw_11pycocotools_5_mask_15toBbox, METH_O, 0};
+static PyObject *__pyx_pw_11pycocotools_5_mask_15toBbox(PyObject *__pyx_self, PyObject *__pyx_v_rleObjs) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("toBbox (wrapper)", 0);
+  __pyx_r = __pyx_pf_11pycocotools_5_mask_14toBbox(__pyx_self, ((PyObject *)__pyx_v_rleObjs));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_11pycocotools_5_mask_14toBbox(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_rleObjs) {
+  struct __pyx_obj_11pycocotools_5_mask_RLEs *__pyx_v_Rs = 0;
+  siz __pyx_v_n;
+  BB __pyx_v__bb;
+  npy_intp __pyx_v_shape[1];
+  PyObject *__pyx_v_bb = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  siz __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  __Pyx_RefNannySetupContext("toBbox", 0);
+
+  /* "pycocotools/_mask.pyx":242
+ * 
+ * def toBbox( rleObjs ):
+ *     cdef RLEs Rs = _frString(rleObjs)             # <<<<<<<<<<<<<<
+ *     cdef siz n = Rs.n
+ *     cdef BB _bb = <BB> malloc(4*n* sizeof(double))
+ */
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_frString); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (!__pyx_t_3) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_rleObjs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_rleObjs};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_rleObjs};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL;
+      __Pyx_INCREF(__pyx_v_rleObjs);
+      __Pyx_GIVEREF(__pyx_v_rleObjs);
+      PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_rleObjs);
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_11pycocotools_5_mask_RLEs))))) __PYX_ERR(0, 242, __pyx_L1_error)
+  __pyx_v_Rs = ((struct __pyx_obj_11pycocotools_5_mask_RLEs *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":243
+ * def toBbox( rleObjs ):
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     cdef siz n = Rs.n             # <<<<<<<<<<<<<<
+ *     cdef BB _bb = <BB> malloc(4*n* sizeof(double))
+ *     rleToBbox( <const RLE*> Rs._R, _bb, n )
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_Rs), __pyx_n_s_n); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 243, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_5 = __Pyx_PyInt_As_siz(__pyx_t_1); if (unlikely((__pyx_t_5 == ((siz)-1)) && PyErr_Occurred())) __PYX_ERR(0, 243, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_n = __pyx_t_5;
+
+  /* "pycocotools/_mask.pyx":244
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     cdef siz n = Rs.n
+ *     cdef BB _bb = <BB> malloc(4*n* sizeof(double))             # <<<<<<<<<<<<<<
+ *     rleToBbox( <const RLE*> Rs._R, _bb, n )
+ *     cdef np.npy_intp shape[1]
+ */
+  __pyx_v__bb = ((BB)malloc(((4 * __pyx_v_n) * (sizeof(double)))));
+
+  /* "pycocotools/_mask.pyx":245
+ *     cdef siz n = Rs.n
+ *     cdef BB _bb = <BB> malloc(4*n* sizeof(double))
+ *     rleToBbox( <const RLE*> Rs._R, _bb, n )             # <<<<<<<<<<<<<<
+ *     cdef np.npy_intp shape[1]
+ *     shape[0] = <np.npy_intp> 4*n
+ */
+  rleToBbox(((RLE const *)__pyx_v_Rs->_R), __pyx_v__bb, __pyx_v_n);
+
+  /* "pycocotools/_mask.pyx":247
+ *     rleToBbox( <const RLE*> Rs._R, _bb, n )
+ *     cdef np.npy_intp shape[1]
+ *     shape[0] = <np.npy_intp> 4*n             # <<<<<<<<<<<<<<
+ *     bb = np.array((1,4*n), dtype=np.double)
+ *     bb = np.PyArray_SimpleNewFromData(1, shape, np.NPY_DOUBLE, _bb).reshape((n, 4))
+ */
+  (__pyx_v_shape[0]) = (((npy_intp)4) * __pyx_v_n);
+
+  /* "pycocotools/_mask.pyx":248
+ *     cdef np.npy_intp shape[1]
+ *     shape[0] = <np.npy_intp> 4*n
+ *     bb = np.array((1,4*n), dtype=np.double)             # <<<<<<<<<<<<<<
+ *     bb = np.PyArray_SimpleNewFromData(1, shape, np.NPY_DOUBLE, _bb).reshape((n, 4))
+ *     PyArray_ENABLEFLAGS(bb, np.NPY_OWNDATA)
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 248, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_array); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 248, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_siz((4 * __pyx_v_n)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 248, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 248, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_INCREF(__pyx_int_1);
+  __Pyx_GIVEREF(__pyx_int_1);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_int_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 248, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4);
+  __pyx_t_4 = 0;
+  __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 248, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 248, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_double); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 248, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(0, 248, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 248, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_v_bb = __pyx_t_6;
+  __pyx_t_6 = 0;
+
+  /* "pycocotools/_mask.pyx":249
+ *     shape[0] = <np.npy_intp> 4*n
+ *     bb = np.array((1,4*n), dtype=np.double)
+ *     bb = np.PyArray_SimpleNewFromData(1, shape, np.NPY_DOUBLE, _bb).reshape((n, 4))             # <<<<<<<<<<<<<<
+ *     PyArray_ENABLEFLAGS(bb, np.NPY_OWNDATA)
+ *     return bb
+ */
+  __pyx_t_4 = PyArray_SimpleNewFromData(1, __pyx_v_shape, NPY_DOUBLE, __pyx_v__bb); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 249, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 249, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyInt_From_siz(__pyx_v_n); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 249, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 249, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4);
+  __Pyx_INCREF(__pyx_int_4);
+  __Pyx_GIVEREF(__pyx_int_4);
+  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_4);
+  __pyx_t_4 = 0;
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
+  }
+  if (!__pyx_t_4) {
+    __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 249, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GOTREF(__pyx_t_6);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_1)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2};
+      __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 249, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2};
+      __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 249, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 249, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL;
+      __Pyx_GIVEREF(__pyx_t_2);
+      PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_t_2);
+      __pyx_t_2 = 0;
+      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 249, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF_SET(__pyx_v_bb, __pyx_t_6);
+  __pyx_t_6 = 0;
+
+  /* "pycocotools/_mask.pyx":250
+ *     bb = np.array((1,4*n), dtype=np.double)
+ *     bb = np.PyArray_SimpleNewFromData(1, shape, np.NPY_DOUBLE, _bb).reshape((n, 4))
+ *     PyArray_ENABLEFLAGS(bb, np.NPY_OWNDATA)             # <<<<<<<<<<<<<<
+ *     return bb
+ * 
+ */
+  if (!(likely(((__pyx_v_bb) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_bb, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 250, __pyx_L1_error)
+  PyArray_ENABLEFLAGS(((PyArrayObject *)__pyx_v_bb), NPY_OWNDATA);
+
+  /* "pycocotools/_mask.pyx":251
+ *     bb = np.PyArray_SimpleNewFromData(1, shape, np.NPY_DOUBLE, _bb).reshape((n, 4))
+ *     PyArray_ENABLEFLAGS(bb, np.NPY_OWNDATA)
+ *     return bb             # <<<<<<<<<<<<<<
+ * 
+ * def frBbox(np.ndarray[np.double_t, ndim=2] bb, siz h, siz w ):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_bb);
+  __pyx_r = __pyx_v_bb;
+  goto __pyx_L0;
+
+  /* "pycocotools/_mask.pyx":241
+ *     return iou.reshape((m,n), order='F')
+ * 
+ * def toBbox( rleObjs ):             # <<<<<<<<<<<<<<
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     cdef siz n = Rs.n
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("pycocotools._mask.toBbox", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_Rs);
+  __Pyx_XDECREF(__pyx_v_bb);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pycocotools/_mask.pyx":253
+ *     return bb
+ * 
+ * def frBbox(np.ndarray[np.double_t, ndim=2] bb, siz h, siz w ):             # <<<<<<<<<<<<<<
+ *     cdef siz n = bb.shape[0]
+ *     Rs = RLEs(n)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11pycocotools_5_mask_17frBbox(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_11pycocotools_5_mask_17frBbox = {"frBbox", (PyCFunction)__pyx_pw_11pycocotools_5_mask_17frBbox, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_11pycocotools_5_mask_17frBbox(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyArrayObject *__pyx_v_bb = 0;
+  siz __pyx_v_h;
+  siz __pyx_v_w;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("frBbox (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_bb,&__pyx_n_s_h,&__pyx_n_s_w,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_bb)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_h)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("frBbox", 1, 3, 3, 1); __PYX_ERR(0, 253, __pyx_L3_error)
+        }
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_w)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("frBbox", 1, 3, 3, 2); __PYX_ERR(0, 253, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "frBbox") < 0)) __PYX_ERR(0, 253, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    }
+    __pyx_v_bb = ((PyArrayObject *)values[0]);
+    __pyx_v_h = __Pyx_PyInt_As_siz(values[1]); if (unlikely((__pyx_v_h == ((siz)-1)) && PyErr_Occurred())) __PYX_ERR(0, 253, __pyx_L3_error)
+    __pyx_v_w = __Pyx_PyInt_As_siz(values[2]); if (unlikely((__pyx_v_w == ((siz)-1)) && PyErr_Occurred())) __PYX_ERR(0, 253, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("frBbox", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 253, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pycocotools._mask.frBbox", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_bb), __pyx_ptype_5numpy_ndarray, 1, "bb", 0))) __PYX_ERR(0, 253, __pyx_L1_error)
+  __pyx_r = __pyx_pf_11pycocotools_5_mask_16frBbox(__pyx_self, __pyx_v_bb, __pyx_v_h, __pyx_v_w);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_11pycocotools_5_mask_16frBbox(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_bb, siz __pyx_v_h, siz __pyx_v_w) {
+  siz __pyx_v_n;
+  struct __pyx_obj_11pycocotools_5_mask_RLEs *__pyx_v_Rs = NULL;
+  PyObject *__pyx_v_objs = NULL;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_bb;
+  __Pyx_Buffer __pyx_pybuffer_bb;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  __Pyx_RefNannySetupContext("frBbox", 0);
+  __pyx_pybuffer_bb.pybuffer.buf = NULL;
+  __pyx_pybuffer_bb.refcount = 0;
+  __pyx_pybuffernd_bb.data = NULL;
+  __pyx_pybuffernd_bb.rcbuffer = &__pyx_pybuffer_bb;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_bb.rcbuffer->pybuffer, (PyObject*)__pyx_v_bb, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 253, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_bb.diminfo[0].strides = __pyx_pybuffernd_bb.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_bb.diminfo[0].shape = __pyx_pybuffernd_bb.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_bb.diminfo[1].strides = __pyx_pybuffernd_bb.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_bb.diminfo[1].shape = __pyx_pybuffernd_bb.rcbuffer->pybuffer.shape[1];
+
+  /* "pycocotools/_mask.pyx":254
+ * 
+ * def frBbox(np.ndarray[np.double_t, ndim=2] bb, siz h, siz w ):
+ *     cdef siz n = bb.shape[0]             # <<<<<<<<<<<<<<
+ *     Rs = RLEs(n)
+ *     rleFrBbox( <RLE*> Rs._R, <const BB> bb.data, h, w, n )
+ */
+  __pyx_v_n = (__pyx_v_bb->dimensions[0]);
+
+  /* "pycocotools/_mask.pyx":255
+ * def frBbox(np.ndarray[np.double_t, ndim=2] bb, siz h, siz w ):
+ *     cdef siz n = bb.shape[0]
+ *     Rs = RLEs(n)             # <<<<<<<<<<<<<<
+ *     rleFrBbox( <RLE*> Rs._R, <const BB> bb.data, h, w, n )
+ *     objs = _toString(Rs)
+ */
+  __pyx_t_1 = __Pyx_PyInt_From_siz(__pyx_v_n); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 255, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 255, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_11pycocotools_5_mask_RLEs), __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 255, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_Rs = ((struct __pyx_obj_11pycocotools_5_mask_RLEs *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":256
+ *     cdef siz n = bb.shape[0]
+ *     Rs = RLEs(n)
+ *     rleFrBbox( <RLE*> Rs._R, <const BB> bb.data, h, w, n )             # <<<<<<<<<<<<<<
+ *     objs = _toString(Rs)
+ *     return objs
+ */
+  rleFrBbox(((RLE *)__pyx_v_Rs->_R), ((BB const )__pyx_v_bb->data), __pyx_v_h, __pyx_v_w, __pyx_v_n);
+
+  /* "pycocotools/_mask.pyx":257
+ *     Rs = RLEs(n)
+ *     rleFrBbox( <RLE*> Rs._R, <const BB> bb.data, h, w, n )
+ *     objs = _toString(Rs)             # <<<<<<<<<<<<<<
+ *     return objs
+ * 
+ */
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_toString); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 257, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (!__pyx_t_3) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_Rs)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 257, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_3, ((PyObject *)__pyx_v_Rs)};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 257, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_3, ((PyObject *)__pyx_v_Rs)};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 257, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 257, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL;
+      __Pyx_INCREF(((PyObject *)__pyx_v_Rs));
+      __Pyx_GIVEREF(((PyObject *)__pyx_v_Rs));
+      PyTuple_SET_ITEM(__pyx_t_4, 0+1, ((PyObject *)__pyx_v_Rs));
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 257, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_objs = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":258
+ *     rleFrBbox( <RLE*> Rs._R, <const BB> bb.data, h, w, n )
+ *     objs = _toString(Rs)
+ *     return objs             # <<<<<<<<<<<<<<
+ * 
+ * def frPoly( poly, siz h, siz w ):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_objs);
+  __pyx_r = __pyx_v_objs;
+  goto __pyx_L0;
+
+  /* "pycocotools/_mask.pyx":253
+ *     return bb
+ * 
+ * def frBbox(np.ndarray[np.double_t, ndim=2] bb, siz h, siz w ):             # <<<<<<<<<<<<<<
+ *     cdef siz n = bb.shape[0]
+ *     Rs = RLEs(n)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_bb.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pycocotools._mask.frBbox", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_bb.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_Rs);
+  __Pyx_XDECREF(__pyx_v_objs);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pycocotools/_mask.pyx":260
+ *     return objs
+ * 
+ * def frPoly( poly, siz h, siz w ):             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.double_t, ndim=1] np_poly
+ *     n = len(poly)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11pycocotools_5_mask_19frPoly(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_11pycocotools_5_mask_19frPoly = {"frPoly", (PyCFunction)__pyx_pw_11pycocotools_5_mask_19frPoly, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_11pycocotools_5_mask_19frPoly(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_poly = 0;
+  siz __pyx_v_h;
+  siz __pyx_v_w;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("frPoly (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_poly,&__pyx_n_s_h,&__pyx_n_s_w,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_poly)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_h)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("frPoly", 1, 3, 3, 1); __PYX_ERR(0, 260, __pyx_L3_error)
+        }
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_w)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("frPoly", 1, 3, 3, 2); __PYX_ERR(0, 260, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "frPoly") < 0)) __PYX_ERR(0, 260, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    }
+    __pyx_v_poly = values[0];
+    __pyx_v_h = __Pyx_PyInt_As_siz(values[1]); if (unlikely((__pyx_v_h == ((siz)-1)) && PyErr_Occurred())) __PYX_ERR(0, 260, __pyx_L3_error)
+    __pyx_v_w = __Pyx_PyInt_As_siz(values[2]); if (unlikely((__pyx_v_w == ((siz)-1)) && PyErr_Occurred())) __PYX_ERR(0, 260, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("frPoly", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 260, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pycocotools._mask.frPoly", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_11pycocotools_5_mask_18frPoly(__pyx_self, __pyx_v_poly, __pyx_v_h, __pyx_v_w);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_11pycocotools_5_mask_18frPoly(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_poly, siz __pyx_v_h, siz __pyx_v_w) {
+  PyArrayObject *__pyx_v_np_poly = 0;
+  Py_ssize_t __pyx_v_n;
+  struct __pyx_obj_11pycocotools_5_mask_RLEs *__pyx_v_Rs = NULL;
+  PyObject *__pyx_v_i = NULL;
+  PyObject *__pyx_v_p = NULL;
+  PyObject *__pyx_v_objs = NULL;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_np_poly;
+  __Pyx_Buffer __pyx_pybuffer_np_poly;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Py_ssize_t __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *(*__pyx_t_4)(PyObject *);
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  PyArrayObject *__pyx_t_10 = NULL;
+  int __pyx_t_11;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  Py_ssize_t __pyx_t_15;
+  Py_ssize_t __pyx_t_16;
+  __Pyx_RefNannySetupContext("frPoly", 0);
+  __pyx_pybuffer_np_poly.pybuffer.buf = NULL;
+  __pyx_pybuffer_np_poly.refcount = 0;
+  __pyx_pybuffernd_np_poly.data = NULL;
+  __pyx_pybuffernd_np_poly.rcbuffer = &__pyx_pybuffer_np_poly;
+
+  /* "pycocotools/_mask.pyx":262
+ * def frPoly( poly, siz h, siz w ):
+ *     cdef np.ndarray[np.double_t, ndim=1] np_poly
+ *     n = len(poly)             # <<<<<<<<<<<<<<
+ *     Rs = RLEs(n)
+ *     for i, p in enumerate(poly):
+ */
+  __pyx_t_1 = PyObject_Length(__pyx_v_poly); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(0, 262, __pyx_L1_error)
+  __pyx_v_n = __pyx_t_1;
+
+  /* "pycocotools/_mask.pyx":263
+ *     cdef np.ndarray[np.double_t, ndim=1] np_poly
+ *     n = len(poly)
+ *     Rs = RLEs(n)             # <<<<<<<<<<<<<<
+ *     for i, p in enumerate(poly):
+ *         np_poly = np.array(p, dtype=np.double, order='F')
+ */
+  __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_n); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 263, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 263, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_11pycocotools_5_mask_RLEs), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 263, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_Rs = ((struct __pyx_obj_11pycocotools_5_mask_RLEs *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "pycocotools/_mask.pyx":264
+ *     n = len(poly)
+ *     Rs = RLEs(n)
+ *     for i, p in enumerate(poly):             # <<<<<<<<<<<<<<
+ *         np_poly = np.array(p, dtype=np.double, order='F')
+ *         rleFrPoly( <RLE*>&Rs._R[i], <const double*> np_poly.data, int(len(p)/2), h, w )
+ */
+  __Pyx_INCREF(__pyx_int_0);
+  __pyx_t_2 = __pyx_int_0;
+  if (likely(PyList_CheckExact(__pyx_v_poly)) || PyTuple_CheckExact(__pyx_v_poly)) {
+    __pyx_t_3 = __pyx_v_poly; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0;
+    __pyx_t_4 = NULL;
+  } else {
+    __pyx_t_1 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_poly); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 264, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 264, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_4)) {
+      if (likely(PyList_CheckExact(__pyx_t_3))) {
+        if (__pyx_t_1 >= PyList_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_5 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(0, 264, __pyx_L1_error)
+        #else
+        __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 264, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        #endif
+      } else {
+        if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(0, 264, __pyx_L1_error)
+        #else
+        __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 264, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        #endif
+      }
+    } else {
+      __pyx_t_5 = __pyx_t_4(__pyx_t_3);
+      if (unlikely(!__pyx_t_5)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(0, 264, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_5);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_p, __pyx_t_5);
+    __pyx_t_5 = 0;
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2);
+    __pyx_t_5 = __Pyx_PyInt_AddObjC(__pyx_t_2, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 264, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_2);
+    __pyx_t_2 = __pyx_t_5;
+    __pyx_t_5 = 0;
+
+    /* "pycocotools/_mask.pyx":265
+ *     Rs = RLEs(n)
+ *     for i, p in enumerate(poly):
+ *         np_poly = np.array(p, dtype=np.double, order='F')             # <<<<<<<<<<<<<<
+ *         rleFrPoly( <RLE*>&Rs._R[i], <const double*> np_poly.data, int(len(p)/2), h, w )
+ *     objs = _toString(Rs)
+ */
+    __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 265, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_array); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 265, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 265, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_INCREF(__pyx_v_p);
+    __Pyx_GIVEREF(__pyx_v_p);
+    PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_p);
+    __pyx_t_7 = PyDict_New(); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 265, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 265, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_double); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 265, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_dtype, __pyx_t_9) < 0) __PYX_ERR(0, 265, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_order, __pyx_n_s_F) < 0) __PYX_ERR(0, 265, __pyx_L1_error)
+    __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_5, __pyx_t_7); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 265, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    if (!(likely(((__pyx_t_9) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_9, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 265, __pyx_L1_error)
+    __pyx_t_10 = ((PyArrayObject *)__pyx_t_9);
+    {
+      __Pyx_BufFmt_StackElem __pyx_stack[1];
+      __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_poly.rcbuffer->pybuffer);
+      __pyx_t_11 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_np_poly.rcbuffer->pybuffer, (PyObject*)__pyx_t_10, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack);
+      if (unlikely(__pyx_t_11 < 0)) {
+        PyErr_Fetch(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14);
+        if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_np_poly.rcbuffer->pybuffer, (PyObject*)__pyx_v_np_poly, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+          Py_XDECREF(__pyx_t_12); Py_XDECREF(__pyx_t_13); Py_XDECREF(__pyx_t_14);
+          __Pyx_RaiseBufferFallbackError();
+        } else {
+          PyErr_Restore(__pyx_t_12, __pyx_t_13, __pyx_t_14);
+        }
+      }
+      __pyx_pybuffernd_np_poly.diminfo[0].strides = __pyx_pybuffernd_np_poly.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_np_poly.diminfo[0].shape = __pyx_pybuffernd_np_poly.rcbuffer->pybuffer.shape[0];
+      if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 265, __pyx_L1_error)
+    }
+    __pyx_t_10 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_np_poly, ((PyArrayObject *)__pyx_t_9));
+    __pyx_t_9 = 0;
+
+    /* "pycocotools/_mask.pyx":266
+ *     for i, p in enumerate(poly):
+ *         np_poly = np.array(p, dtype=np.double, order='F')
+ *         rleFrPoly( <RLE*>&Rs._R[i], <const double*> np_poly.data, int(len(p)/2), h, w )             # <<<<<<<<<<<<<<
+ *     objs = _toString(Rs)
+ *     return objs
+ */
+    __pyx_t_15 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_15 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 266, __pyx_L1_error)
+    __pyx_t_16 = PyObject_Length(__pyx_v_p); if (unlikely(__pyx_t_16 == -1)) __PYX_ERR(0, 266, __pyx_L1_error)
+    rleFrPoly(((RLE *)(&(__pyx_v_Rs->_R[__pyx_t_15]))), ((double const *)__pyx_v_np_poly->data), ((siz)__Pyx_div_Py_ssize_t(__pyx_t_16, 2)), __pyx_v_h, __pyx_v_w);
+
+    /* "pycocotools/_mask.pyx":264
+ *     n = len(poly)
+ *     Rs = RLEs(n)
+ *     for i, p in enumerate(poly):             # <<<<<<<<<<<<<<
+ *         np_poly = np.array(p, dtype=np.double, order='F')
+ *         rleFrPoly( <RLE*>&Rs._R[i], <const double*> np_poly.data, int(len(p)/2), h, w )
+ */
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pycocotools/_mask.pyx":267
+ *         np_poly = np.array(p, dtype=np.double, order='F')
+ *         rleFrPoly( <RLE*>&Rs._R[i], <const double*> np_poly.data, int(len(p)/2), h, w )
+ *     objs = _toString(Rs)             # <<<<<<<<<<<<<<
+ *     return objs
+ * 
+ */
+  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_toString); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 267, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_9 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_9)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_9);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (!__pyx_t_9) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_Rs)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 267, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_9, ((PyObject *)__pyx_v_Rs)};
+      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 267, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_9, ((PyObject *)__pyx_v_Rs)};
+      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 267, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+    } else
+    #endif
+    {
+      __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 267, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_9); __pyx_t_9 = NULL;
+      __Pyx_INCREF(((PyObject *)__pyx_v_Rs));
+      __Pyx_GIVEREF(((PyObject *)__pyx_v_Rs));
+      PyTuple_SET_ITEM(__pyx_t_7, 0+1, ((PyObject *)__pyx_v_Rs));
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 267, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_objs = __pyx_t_2;
+  __pyx_t_2 = 0;
+
+  /* "pycocotools/_mask.pyx":268
+ *         rleFrPoly( <RLE*>&Rs._R[i], <const double*> np_poly.data, int(len(p)/2), h, w )
+ *     objs = _toString(Rs)
+ *     return objs             # <<<<<<<<<<<<<<
+ * 
+ * def frUncompressedRLE(ucRles, siz h, siz w):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_objs);
+  __pyx_r = __pyx_v_objs;
+  goto __pyx_L0;
+
+  /* "pycocotools/_mask.pyx":260
+ *     return objs
+ * 
+ * def frPoly( poly, siz h, siz w ):             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.double_t, ndim=1] np_poly
+ *     n = len(poly)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_poly.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pycocotools._mask.frPoly", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_poly.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_np_poly);
+  __Pyx_XDECREF((PyObject *)__pyx_v_Rs);
+  __Pyx_XDECREF(__pyx_v_i);
+  __Pyx_XDECREF(__pyx_v_p);
+  __Pyx_XDECREF(__pyx_v_objs);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pycocotools/_mask.pyx":270
+ *     return objs
+ * 
+ * def frUncompressedRLE(ucRles, siz h, siz w):             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.uint32_t, ndim=1] cnts
+ *     cdef RLE R
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11pycocotools_5_mask_21frUncompressedRLE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_11pycocotools_5_mask_21frUncompressedRLE = {"frUncompressedRLE", (PyCFunction)__pyx_pw_11pycocotools_5_mask_21frUncompressedRLE, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_11pycocotools_5_mask_21frUncompressedRLE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_ucRles = 0;
+  CYTHON_UNUSED siz __pyx_v_h;
+  CYTHON_UNUSED siz __pyx_v_w;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("frUncompressedRLE (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ucRles,&__pyx_n_s_h,&__pyx_n_s_w,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ucRles)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_h)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("frUncompressedRLE", 1, 3, 3, 1); __PYX_ERR(0, 270, __pyx_L3_error)
+        }
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_w)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("frUncompressedRLE", 1, 3, 3, 2); __PYX_ERR(0, 270, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "frUncompressedRLE") < 0)) __PYX_ERR(0, 270, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    }
+    __pyx_v_ucRles = values[0];
+    __pyx_v_h = __Pyx_PyInt_As_siz(values[1]); if (unlikely((__pyx_v_h == ((siz)-1)) && PyErr_Occurred())) __PYX_ERR(0, 270, __pyx_L3_error)
+    __pyx_v_w = __Pyx_PyInt_As_siz(values[2]); if (unlikely((__pyx_v_w == ((siz)-1)) && PyErr_Occurred())) __PYX_ERR(0, 270, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("frUncompressedRLE", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 270, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pycocotools._mask.frUncompressedRLE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_11pycocotools_5_mask_20frUncompressedRLE(__pyx_self, __pyx_v_ucRles, __pyx_v_h, __pyx_v_w);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_11pycocotools_5_mask_20frUncompressedRLE(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ucRles, CYTHON_UNUSED siz __pyx_v_h, CYTHON_UNUSED siz __pyx_v_w) {
+  PyArrayObject *__pyx_v_cnts = 0;
+  RLE __pyx_v_R;
+  uint *__pyx_v_data;
+  Py_ssize_t __pyx_v_n;
+  PyObject *__pyx_v_objs = NULL;
+  Py_ssize_t __pyx_v_i;
+  struct __pyx_obj_11pycocotools_5_mask_RLEs *__pyx_v_Rs = NULL;
+  Py_ssize_t __pyx_v_j;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_cnts;
+  __Pyx_Buffer __pyx_pybuffer_cnts;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Py_ssize_t __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  Py_ssize_t __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyArrayObject *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  Py_ssize_t __pyx_t_13;
+  Py_ssize_t __pyx_t_14;
+  Py_ssize_t __pyx_t_15;
+  RLE __pyx_t_16;
+  siz __pyx_t_17;
+  int __pyx_t_18;
+  __Pyx_RefNannySetupContext("frUncompressedRLE", 0);
+  __pyx_pybuffer_cnts.pybuffer.buf = NULL;
+  __pyx_pybuffer_cnts.refcount = 0;
+  __pyx_pybuffernd_cnts.data = NULL;
+  __pyx_pybuffernd_cnts.rcbuffer = &__pyx_pybuffer_cnts;
+
+  /* "pycocotools/_mask.pyx":274
+ *     cdef RLE R
+ *     cdef uint *data
+ *     n = len(ucRles)             # <<<<<<<<<<<<<<
+ *     objs = []
+ *     for i in range(n):
+ */
+  __pyx_t_1 = PyObject_Length(__pyx_v_ucRles); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(0, 274, __pyx_L1_error)
+  __pyx_v_n = __pyx_t_1;
+
+  /* "pycocotools/_mask.pyx":275
+ *     cdef uint *data
+ *     n = len(ucRles)
+ *     objs = []             # <<<<<<<<<<<<<<
+ *     for i in range(n):
+ *         Rs = RLEs(1)
+ */
+  __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 275, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_v_objs = ((PyObject*)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "pycocotools/_mask.pyx":276
+ *     n = len(ucRles)
+ *     objs = []
+ *     for i in range(n):             # <<<<<<<<<<<<<<
+ *         Rs = RLEs(1)
+ *         cnts = np.array(ucRles[i]['counts'], dtype=np.uint32)
+ */
+  __pyx_t_1 = __pyx_v_n;
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_1; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+
+    /* "pycocotools/_mask.pyx":277
+ *     objs = []
+ *     for i in range(n):
+ *         Rs = RLEs(1)             # <<<<<<<<<<<<<<
+ *         cnts = np.array(ucRles[i]['counts'], dtype=np.uint32)
+ *         # time for malloc can be saved here but it's fine
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_11pycocotools_5_mask_RLEs), __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 277, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_XDECREF_SET(__pyx_v_Rs, ((struct __pyx_obj_11pycocotools_5_mask_RLEs *)__pyx_t_2));
+    __pyx_t_2 = 0;
+
+    /* "pycocotools/_mask.pyx":278
+ *     for i in range(n):
+ *         Rs = RLEs(1)
+ *         cnts = np.array(ucRles[i]['counts'], dtype=np.uint32)             # <<<<<<<<<<<<<<
+ *         # time for malloc can be saved here but it's fine
+ *         data = <uint*> malloc(len(cnts)* sizeof(uint))
+ */
+    __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 278, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_array); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 278, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_ucRles, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 278, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_5 = PyObject_GetItem(__pyx_t_2, __pyx_n_s_counts); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 278, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 278, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
+    __pyx_t_5 = 0;
+    __pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 278, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 278, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uint32); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 278, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(0, 278, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 278, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 278, __pyx_L1_error)
+    __pyx_t_8 = ((PyArrayObject *)__pyx_t_7);
+    {
+      __Pyx_BufFmt_StackElem __pyx_stack[1];
+      __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_cnts.rcbuffer->pybuffer);
+      __pyx_t_9 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_cnts.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack);
+      if (unlikely(__pyx_t_9 < 0)) {
+        PyErr_Fetch(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12);
+        if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_cnts.rcbuffer->pybuffer, (PyObject*)__pyx_v_cnts, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+          Py_XDECREF(__pyx_t_10); Py_XDECREF(__pyx_t_11); Py_XDECREF(__pyx_t_12);
+          __Pyx_RaiseBufferFallbackError();
+        } else {
+          PyErr_Restore(__pyx_t_10, __pyx_t_11, __pyx_t_12);
+        }
+      }
+      __pyx_pybuffernd_cnts.diminfo[0].strides = __pyx_pybuffernd_cnts.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_cnts.diminfo[0].shape = __pyx_pybuffernd_cnts.rcbuffer->pybuffer.shape[0];
+      if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 278, __pyx_L1_error)
+    }
+    __pyx_t_8 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_cnts, ((PyArrayObject *)__pyx_t_7));
+    __pyx_t_7 = 0;
+
+    /* "pycocotools/_mask.pyx":280
+ *         cnts = np.array(ucRles[i]['counts'], dtype=np.uint32)
+ *         # time for malloc can be saved here but it's fine
+ *         data = <uint*> malloc(len(cnts)* sizeof(uint))             # <<<<<<<<<<<<<<
+ *         for j in range(len(cnts)):
+ *             data[j] = <uint> cnts[j]
+ */
+    __pyx_t_13 = PyObject_Length(((PyObject *)__pyx_v_cnts)); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 280, __pyx_L1_error)
+    __pyx_v_data = ((uint *)malloc((__pyx_t_13 * (sizeof(unsigned int)))));
+
+    /* "pycocotools/_mask.pyx":281
+ *         # time for malloc can be saved here but it's fine
+ *         data = <uint*> malloc(len(cnts)* sizeof(uint))
+ *         for j in range(len(cnts)):             # <<<<<<<<<<<<<<
+ *             data[j] = <uint> cnts[j]
+ *         R = RLE(ucRles[i]['size'][0], ucRles[i]['size'][1], len(cnts), <uint*> data)
+ */
+    __pyx_t_13 = PyObject_Length(((PyObject *)__pyx_v_cnts)); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 281, __pyx_L1_error)
+    for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) {
+      __pyx_v_j = __pyx_t_14;
+
+      /* "pycocotools/_mask.pyx":282
+ *         data = <uint*> malloc(len(cnts)* sizeof(uint))
+ *         for j in range(len(cnts)):
+ *             data[j] = <uint> cnts[j]             # <<<<<<<<<<<<<<
+ *         R = RLE(ucRles[i]['size'][0], ucRles[i]['size'][1], len(cnts), <uint*> data)
+ *         Rs._R[0] = R
+ */
+      __pyx_t_15 = __pyx_v_j;
+      __pyx_t_9 = -1;
+      if (__pyx_t_15 < 0) {
+        __pyx_t_15 += __pyx_pybuffernd_cnts.diminfo[0].shape;
+        if (unlikely(__pyx_t_15 < 0)) __pyx_t_9 = 0;
+      } else if (unlikely(__pyx_t_15 >= __pyx_pybuffernd_cnts.diminfo[0].shape)) __pyx_t_9 = 0;
+      if (unlikely(__pyx_t_9 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_9);
+        __PYX_ERR(0, 282, __pyx_L1_error)
+      }
+      (__pyx_v_data[__pyx_v_j]) = ((uint)(*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_uint32_t *, __pyx_pybuffernd_cnts.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_cnts.diminfo[0].strides)));
+    }
+
+    /* "pycocotools/_mask.pyx":283
+ *         for j in range(len(cnts)):
+ *             data[j] = <uint> cnts[j]
+ *         R = RLE(ucRles[i]['size'][0], ucRles[i]['size'][1], len(cnts), <uint*> data)             # <<<<<<<<<<<<<<
+ *         Rs._R[0] = R
+ *         objs.append(_toString(Rs)[0])
+ */
+    __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_ucRles, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 283, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_5 = PyObject_GetItem(__pyx_t_7, __pyx_n_s_size); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 283, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_5, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 283, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_17 = __Pyx_PyInt_As_siz(__pyx_t_7); if (unlikely((__pyx_t_17 == ((siz)-1)) && PyErr_Occurred())) __PYX_ERR(0, 283, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_16.h = __pyx_t_17;
+    __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_ucRles, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 283, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_5 = PyObject_GetItem(__pyx_t_7, __pyx_n_s_size); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 283, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 283, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_17 = __Pyx_PyInt_As_siz(__pyx_t_7); if (unlikely((__pyx_t_17 == ((siz)-1)) && PyErr_Occurred())) __PYX_ERR(0, 283, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_16.w = __pyx_t_17;
+    __pyx_t_13 = PyObject_Length(((PyObject *)__pyx_v_cnts)); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 283, __pyx_L1_error)
+    __pyx_t_16.m = __pyx_t_13;
+    __pyx_t_16.cnts = ((uint *)__pyx_v_data);
+    __pyx_v_R = __pyx_t_16;
+
+    /* "pycocotools/_mask.pyx":284
+ *             data[j] = <uint> cnts[j]
+ *         R = RLE(ucRles[i]['size'][0], ucRles[i]['size'][1], len(cnts), <uint*> data)
+ *         Rs._R[0] = R             # <<<<<<<<<<<<<<
+ *         objs.append(_toString(Rs)[0])
+ *     return objs
+ */
+    (__pyx_v_Rs->_R[0]) = __pyx_v_R;
+
+    /* "pycocotools/_mask.pyx":285
+ *         R = RLE(ucRles[i]['size'][0], ucRles[i]['size'][1], len(cnts), <uint*> data)
+ *         Rs._R[0] = R
+ *         objs.append(_toString(Rs)[0])             # <<<<<<<<<<<<<<
+ *     return objs
+ * 
+ */
+    __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_toString); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 285, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_2 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5);
+      if (likely(__pyx_t_2)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+        __Pyx_INCREF(__pyx_t_2);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+      }
+    }
+    if (!__pyx_t_2) {
+      __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_5, ((PyObject *)__pyx_v_Rs)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 285, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_5)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_2, ((PyObject *)__pyx_v_Rs)};
+        __pyx_t_7 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 285, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __Pyx_GOTREF(__pyx_t_7);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_2, ((PyObject *)__pyx_v_Rs)};
+        __pyx_t_7 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 285, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __Pyx_GOTREF(__pyx_t_7);
+      } else
+      #endif
+      {
+        __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 285, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
+        __Pyx_INCREF(((PyObject *)__pyx_v_Rs));
+        __Pyx_GIVEREF(((PyObject *)__pyx_v_Rs));
+        PyTuple_SET_ITEM(__pyx_t_4, 0+1, ((PyObject *)__pyx_v_Rs));
+        __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 285, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 285, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_18 = __Pyx_PyList_Append(__pyx_v_objs, __pyx_t_5); if (unlikely(__pyx_t_18 == -1)) __PYX_ERR(0, 285, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  }
+
+  /* "pycocotools/_mask.pyx":286
+ *         Rs._R[0] = R
+ *         objs.append(_toString(Rs)[0])
+ *     return objs             # <<<<<<<<<<<<<<
+ * 
+ * def frPyObjects(pyobj, h, w):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_objs);
+  __pyx_r = __pyx_v_objs;
+  goto __pyx_L0;
+
+  /* "pycocotools/_mask.pyx":270
+ *     return objs
+ * 
+ * def frUncompressedRLE(ucRles, siz h, siz w):             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.uint32_t, ndim=1] cnts
+ *     cdef RLE R
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_cnts.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pycocotools._mask.frUncompressedRLE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_cnts.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_cnts);
+  __Pyx_XDECREF(__pyx_v_objs);
+  __Pyx_XDECREF((PyObject *)__pyx_v_Rs);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pycocotools/_mask.pyx":288
+ *     return objs
+ * 
+ * def frPyObjects(pyobj, h, w):             # <<<<<<<<<<<<<<
+ *     # encode rle from a list of python objects
+ *     if type(pyobj) == np.ndarray:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11pycocotools_5_mask_23frPyObjects(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_11pycocotools_5_mask_23frPyObjects = {"frPyObjects", (PyCFunction)__pyx_pw_11pycocotools_5_mask_23frPyObjects, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_11pycocotools_5_mask_23frPyObjects(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_pyobj = 0;
+  PyObject *__pyx_v_h = 0;
+  PyObject *__pyx_v_w = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("frPyObjects (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyobj,&__pyx_n_s_h,&__pyx_n_s_w,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pyobj)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_h)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("frPyObjects", 1, 3, 3, 1); __PYX_ERR(0, 288, __pyx_L3_error)
+        }
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_w)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("frPyObjects", 1, 3, 3, 2); __PYX_ERR(0, 288, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "frPyObjects") < 0)) __PYX_ERR(0, 288, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    }
+    __pyx_v_pyobj = values[0];
+    __pyx_v_h = values[1];
+    __pyx_v_w = values[2];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("frPyObjects", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 288, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pycocotools._mask.frPyObjects", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_11pycocotools_5_mask_22frPyObjects(__pyx_self, __pyx_v_pyobj, __pyx_v_h, __pyx_v_w);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_11pycocotools_5_mask_22frPyObjects(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_pyobj, PyObject *__pyx_v_h, PyObject *__pyx_v_w) {
+  PyObject *__pyx_v_objs = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  Py_ssize_t __pyx_t_8;
+  int __pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  __Pyx_RefNannySetupContext("frPyObjects", 0);
+
+  /* "pycocotools/_mask.pyx":290
+ * def frPyObjects(pyobj, h, w):
+ *     # encode rle from a list of python objects
+ *     if type(pyobj) == np.ndarray:             # <<<<<<<<<<<<<<
+ *         objs = frBbox(pyobj, h, w)
+ *     elif type(pyobj) == list and len(pyobj[0]) == 4:
+ */
+  __pyx_t_1 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_pyobj)), ((PyObject *)__pyx_ptype_5numpy_ndarray), Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 290, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 290, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (__pyx_t_2) {
+
+    /* "pycocotools/_mask.pyx":291
+ *     # encode rle from a list of python objects
+ *     if type(pyobj) == np.ndarray:
+ *         objs = frBbox(pyobj, h, w)             # <<<<<<<<<<<<<<
+ *     elif type(pyobj) == list and len(pyobj[0]) == 4:
+ *         objs = frBbox(pyobj, h, w)
+ */
+    __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_frBbox); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 291, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = NULL;
+    __pyx_t_5 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+      if (likely(__pyx_t_4)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+        __Pyx_INCREF(__pyx_t_4);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_3, function);
+        __pyx_t_5 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_v_pyobj, __pyx_v_h, __pyx_v_w};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 291, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_v_pyobj, __pyx_v_h, __pyx_v_w};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 291, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_6 = PyTuple_New(3+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 291, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      if (__pyx_t_4) {
+        __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL;
+      }
+      __Pyx_INCREF(__pyx_v_pyobj);
+      __Pyx_GIVEREF(__pyx_v_pyobj);
+      PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, __pyx_v_pyobj);
+      __Pyx_INCREF(__pyx_v_h);
+      __Pyx_GIVEREF(__pyx_v_h);
+      PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_h);
+      __Pyx_INCREF(__pyx_v_w);
+      __Pyx_GIVEREF(__pyx_v_w);
+      PyTuple_SET_ITEM(__pyx_t_6, 2+__pyx_t_5, __pyx_v_w);
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 291, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_v_objs = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "pycocotools/_mask.pyx":290
+ * def frPyObjects(pyobj, h, w):
+ *     # encode rle from a list of python objects
+ *     if type(pyobj) == np.ndarray:             # <<<<<<<<<<<<<<
+ *         objs = frBbox(pyobj, h, w)
+ *     elif type(pyobj) == list and len(pyobj[0]) == 4:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pycocotools/_mask.pyx":292
+ *     if type(pyobj) == np.ndarray:
+ *         objs = frBbox(pyobj, h, w)
+ *     elif type(pyobj) == list and len(pyobj[0]) == 4:             # <<<<<<<<<<<<<<
+ *         objs = frBbox(pyobj, h, w)
+ *     elif type(pyobj) == list and len(pyobj[0]) > 4:
+ */
+  __pyx_t_1 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_pyobj)), ((PyObject *)(&PyList_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 292, __pyx_L1_error)
+  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 292, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (__pyx_t_7) {
+  } else {
+    __pyx_t_2 = __pyx_t_7;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_pyobj, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 292, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_8 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 292, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_7 = ((__pyx_t_8 == 4) != 0);
+  __pyx_t_2 = __pyx_t_7;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_2) {
+
+    /* "pycocotools/_mask.pyx":293
+ *         objs = frBbox(pyobj, h, w)
+ *     elif type(pyobj) == list and len(pyobj[0]) == 4:
+ *         objs = frBbox(pyobj, h, w)             # <<<<<<<<<<<<<<
+ *     elif type(pyobj) == list and len(pyobj[0]) > 4:
+ *         objs = frPoly(pyobj, h, w)
+ */
+    __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_frBbox); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 293, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_6 = NULL;
+    __pyx_t_5 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3);
+      if (likely(__pyx_t_6)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+        __Pyx_INCREF(__pyx_t_6);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_3, function);
+        __pyx_t_5 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_v_pyobj, __pyx_v_h, __pyx_v_w};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 293, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_v_pyobj, __pyx_v_h, __pyx_v_w};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 293, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(3+__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 293, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      if (__pyx_t_6) {
+        __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6); __pyx_t_6 = NULL;
+      }
+      __Pyx_INCREF(__pyx_v_pyobj);
+      __Pyx_GIVEREF(__pyx_v_pyobj);
+      PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_5, __pyx_v_pyobj);
+      __Pyx_INCREF(__pyx_v_h);
+      __Pyx_GIVEREF(__pyx_v_h);
+      PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_5, __pyx_v_h);
+      __Pyx_INCREF(__pyx_v_w);
+      __Pyx_GIVEREF(__pyx_v_w);
+      PyTuple_SET_ITEM(__pyx_t_4, 2+__pyx_t_5, __pyx_v_w);
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 293, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_v_objs = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "pycocotools/_mask.pyx":292
+ *     if type(pyobj) == np.ndarray:
+ *         objs = frBbox(pyobj, h, w)
+ *     elif type(pyobj) == list and len(pyobj[0]) == 4:             # <<<<<<<<<<<<<<
+ *         objs = frBbox(pyobj, h, w)
+ *     elif type(pyobj) == list and len(pyobj[0]) > 4:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pycocotools/_mask.pyx":294
+ *     elif type(pyobj) == list and len(pyobj[0]) == 4:
+ *         objs = frBbox(pyobj, h, w)
+ *     elif type(pyobj) == list and len(pyobj[0]) > 4:             # <<<<<<<<<<<<<<
+ *         objs = frPoly(pyobj, h, w)
+ *     elif type(pyobj) == list and type(pyobj[0]) == dict \
+ */
+  __pyx_t_1 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_pyobj)), ((PyObject *)(&PyList_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 294, __pyx_L1_error)
+  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 294, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (__pyx_t_7) {
+  } else {
+    __pyx_t_2 = __pyx_t_7;
+    goto __pyx_L6_bool_binop_done;
+  }
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_pyobj, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 294, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_8 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 294, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_7 = ((__pyx_t_8 > 4) != 0);
+  __pyx_t_2 = __pyx_t_7;
+  __pyx_L6_bool_binop_done:;
+  if (__pyx_t_2) {
+
+    /* "pycocotools/_mask.pyx":295
+ *         objs = frBbox(pyobj, h, w)
+ *     elif type(pyobj) == list and len(pyobj[0]) > 4:
+ *         objs = frPoly(pyobj, h, w)             # <<<<<<<<<<<<<<
+ *     elif type(pyobj) == list and type(pyobj[0]) == dict \
+ *         and 'counts' in pyobj[0] and 'size' in pyobj[0]:
+ */
+    __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_frPoly); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 295, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = NULL;
+    __pyx_t_5 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+      if (likely(__pyx_t_4)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+        __Pyx_INCREF(__pyx_t_4);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_3, function);
+        __pyx_t_5 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_v_pyobj, __pyx_v_h, __pyx_v_w};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 295, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_v_pyobj, __pyx_v_h, __pyx_v_w};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 295, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_6 = PyTuple_New(3+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 295, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      if (__pyx_t_4) {
+        __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL;
+      }
+      __Pyx_INCREF(__pyx_v_pyobj);
+      __Pyx_GIVEREF(__pyx_v_pyobj);
+      PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, __pyx_v_pyobj);
+      __Pyx_INCREF(__pyx_v_h);
+      __Pyx_GIVEREF(__pyx_v_h);
+      PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_h);
+      __Pyx_INCREF(__pyx_v_w);
+      __Pyx_GIVEREF(__pyx_v_w);
+      PyTuple_SET_ITEM(__pyx_t_6, 2+__pyx_t_5, __pyx_v_w);
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 295, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_v_objs = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "pycocotools/_mask.pyx":294
+ *     elif type(pyobj) == list and len(pyobj[0]) == 4:
+ *         objs = frBbox(pyobj, h, w)
+ *     elif type(pyobj) == list and len(pyobj[0]) > 4:             # <<<<<<<<<<<<<<
+ *         objs = frPoly(pyobj, h, w)
+ *     elif type(pyobj) == list and type(pyobj[0]) == dict \
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pycocotools/_mask.pyx":296
+ *     elif type(pyobj) == list and len(pyobj[0]) > 4:
+ *         objs = frPoly(pyobj, h, w)
+ *     elif type(pyobj) == list and type(pyobj[0]) == dict \             # <<<<<<<<<<<<<<
+ *         and 'counts' in pyobj[0] and 'size' in pyobj[0]:
+ *         objs = frUncompressedRLE(pyobj, h, w)
+ */
+  __pyx_t_1 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_pyobj)), ((PyObject *)(&PyList_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 296, __pyx_L1_error)
+  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 296, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (__pyx_t_7) {
+  } else {
+    __pyx_t_2 = __pyx_t_7;
+    goto __pyx_L8_bool_binop_done;
+  }
+
+  /* "pycocotools/_mask.pyx":297
+ *         objs = frPoly(pyobj, h, w)
+ *     elif type(pyobj) == list and type(pyobj[0]) == dict \
+ *         and 'counts' in pyobj[0] and 'size' in pyobj[0]:             # <<<<<<<<<<<<<<
+ *         objs = frUncompressedRLE(pyobj, h, w)
+ *     # encode rle from single python object
+ */
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_pyobj, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 296, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+
+  /* "pycocotools/_mask.pyx":296
+ *     elif type(pyobj) == list and len(pyobj[0]) > 4:
+ *         objs = frPoly(pyobj, h, w)
+ *     elif type(pyobj) == list and type(pyobj[0]) == dict \             # <<<<<<<<<<<<<<
+ *         and 'counts' in pyobj[0] and 'size' in pyobj[0]:
+ *         objs = frUncompressedRLE(pyobj, h, w)
+ */
+  __pyx_t_3 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_t_1)), ((PyObject *)(&PyDict_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 296, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 296, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (__pyx_t_7) {
+  } else {
+    __pyx_t_2 = __pyx_t_7;
+    goto __pyx_L8_bool_binop_done;
+  }
+
+  /* "pycocotools/_mask.pyx":297
+ *         objs = frPoly(pyobj, h, w)
+ *     elif type(pyobj) == list and type(pyobj[0]) == dict \
+ *         and 'counts' in pyobj[0] and 'size' in pyobj[0]:             # <<<<<<<<<<<<<<
+ *         objs = frUncompressedRLE(pyobj, h, w)
+ *     # encode rle from single python object
+ */
+  __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_pyobj, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 297, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_n_s_counts, __pyx_t_3, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 297, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_9 = (__pyx_t_7 != 0);
+  if (__pyx_t_9) {
+  } else {
+    __pyx_t_2 = __pyx_t_9;
+    goto __pyx_L8_bool_binop_done;
+  }
+  __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_pyobj, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 297, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_9 = (__Pyx_PySequence_ContainsTF(__pyx_n_s_size, __pyx_t_3, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 297, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_7 = (__pyx_t_9 != 0);
+  __pyx_t_2 = __pyx_t_7;
+  __pyx_L8_bool_binop_done:;
+
+  /* "pycocotools/_mask.pyx":296
+ *     elif type(pyobj) == list and len(pyobj[0]) > 4:
+ *         objs = frPoly(pyobj, h, w)
+ *     elif type(pyobj) == list and type(pyobj[0]) == dict \             # <<<<<<<<<<<<<<
+ *         and 'counts' in pyobj[0] and 'size' in pyobj[0]:
+ *         objs = frUncompressedRLE(pyobj, h, w)
+ */
+  if (__pyx_t_2) {
+
+    /* "pycocotools/_mask.pyx":298
+ *     elif type(pyobj) == list and type(pyobj[0]) == dict \
+ *         and 'counts' in pyobj[0] and 'size' in pyobj[0]:
+ *         objs = frUncompressedRLE(pyobj, h, w)             # <<<<<<<<<<<<<<
+ *     # encode rle from single python object
+ *     elif type(pyobj) == list and len(pyobj) == 4:
+ */
+    __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_frUncompressedRLE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 298, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_6 = NULL;
+    __pyx_t_5 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1);
+      if (likely(__pyx_t_6)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+        __Pyx_INCREF(__pyx_t_6);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_1, function);
+        __pyx_t_5 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_1)) {
+      PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_v_pyobj, __pyx_v_h, __pyx_v_w};
+      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 298, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
+      PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_v_pyobj, __pyx_v_h, __pyx_v_w};
+      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 298, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(3+__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 298, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      if (__pyx_t_6) {
+        __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6); __pyx_t_6 = NULL;
+      }
+      __Pyx_INCREF(__pyx_v_pyobj);
+      __Pyx_GIVEREF(__pyx_v_pyobj);
+      PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_5, __pyx_v_pyobj);
+      __Pyx_INCREF(__pyx_v_h);
+      __Pyx_GIVEREF(__pyx_v_h);
+      PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_5, __pyx_v_h);
+      __Pyx_INCREF(__pyx_v_w);
+      __Pyx_GIVEREF(__pyx_v_w);
+      PyTuple_SET_ITEM(__pyx_t_4, 2+__pyx_t_5, __pyx_v_w);
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 298, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_v_objs = __pyx_t_3;
+    __pyx_t_3 = 0;
+
+    /* "pycocotools/_mask.pyx":296
+ *     elif type(pyobj) == list and len(pyobj[0]) > 4:
+ *         objs = frPoly(pyobj, h, w)
+ *     elif type(pyobj) == list and type(pyobj[0]) == dict \             # <<<<<<<<<<<<<<
+ *         and 'counts' in pyobj[0] and 'size' in pyobj[0]:
+ *         objs = frUncompressedRLE(pyobj, h, w)
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pycocotools/_mask.pyx":300
+ *         objs = frUncompressedRLE(pyobj, h, w)
+ *     # encode rle from single python object
+ *     elif type(pyobj) == list and len(pyobj) == 4:             # <<<<<<<<<<<<<<
+ *         objs = frBbox([pyobj], h, w)[0]
+ *     elif type(pyobj) == list and len(pyobj) > 4:
+ */
+  __pyx_t_3 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_pyobj)), ((PyObject *)(&PyList_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 300, __pyx_L1_error)
+  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 300, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (__pyx_t_7) {
+  } else {
+    __pyx_t_2 = __pyx_t_7;
+    goto __pyx_L12_bool_binop_done;
+  }
+  __pyx_t_8 = PyObject_Length(__pyx_v_pyobj); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 300, __pyx_L1_error)
+  __pyx_t_7 = ((__pyx_t_8 == 4) != 0);
+  __pyx_t_2 = __pyx_t_7;
+  __pyx_L12_bool_binop_done:;
+  if (__pyx_t_2) {
+
+    /* "pycocotools/_mask.pyx":301
+ *     # encode rle from single python object
+ *     elif type(pyobj) == list and len(pyobj) == 4:
+ *         objs = frBbox([pyobj], h, w)[0]             # <<<<<<<<<<<<<<
+ *     elif type(pyobj) == list and len(pyobj) > 4:
+ *         objs = frPoly([pyobj], h, w)[0]
+ */
+    __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_frBbox); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 301, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_4 = PyList_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 301, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_INCREF(__pyx_v_pyobj);
+    __Pyx_GIVEREF(__pyx_v_pyobj);
+    PyList_SET_ITEM(__pyx_t_4, 0, __pyx_v_pyobj);
+    __pyx_t_6 = NULL;
+    __pyx_t_5 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1);
+      if (likely(__pyx_t_6)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+        __Pyx_INCREF(__pyx_t_6);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_1, function);
+        __pyx_t_5 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_1)) {
+      PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_t_4, __pyx_v_h, __pyx_v_w};
+      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 301, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
+      PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_t_4, __pyx_v_h, __pyx_v_w};
+      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 301, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_10 = PyTuple_New(3+__pyx_t_5); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 301, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_10);
+      if (__pyx_t_6) {
+        __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_6); __pyx_t_6 = NULL;
+      }
+      __Pyx_GIVEREF(__pyx_t_4);
+      PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_5, __pyx_t_4);
+      __Pyx_INCREF(__pyx_v_h);
+      __Pyx_GIVEREF(__pyx_v_h);
+      PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_5, __pyx_v_h);
+      __Pyx_INCREF(__pyx_v_w);
+      __Pyx_GIVEREF(__pyx_v_w);
+      PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_5, __pyx_v_w);
+      __pyx_t_4 = 0;
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 301, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 301, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_v_objs = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "pycocotools/_mask.pyx":300
+ *         objs = frUncompressedRLE(pyobj, h, w)
+ *     # encode rle from single python object
+ *     elif type(pyobj) == list and len(pyobj) == 4:             # <<<<<<<<<<<<<<
+ *         objs = frBbox([pyobj], h, w)[0]
+ *     elif type(pyobj) == list and len(pyobj) > 4:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pycocotools/_mask.pyx":302
+ *     elif type(pyobj) == list and len(pyobj) == 4:
+ *         objs = frBbox([pyobj], h, w)[0]
+ *     elif type(pyobj) == list and len(pyobj) > 4:             # <<<<<<<<<<<<<<
+ *         objs = frPoly([pyobj], h, w)[0]
+ *     elif type(pyobj) == dict and 'counts' in pyobj and 'size' in pyobj:
+ */
+  __pyx_t_1 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_pyobj)), ((PyObject *)(&PyList_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 302, __pyx_L1_error)
+  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 302, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (__pyx_t_7) {
+  } else {
+    __pyx_t_2 = __pyx_t_7;
+    goto __pyx_L14_bool_binop_done;
+  }
+  __pyx_t_8 = PyObject_Length(__pyx_v_pyobj); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 302, __pyx_L1_error)
+  __pyx_t_7 = ((__pyx_t_8 > 4) != 0);
+  __pyx_t_2 = __pyx_t_7;
+  __pyx_L14_bool_binop_done:;
+  if (__pyx_t_2) {
+
+    /* "pycocotools/_mask.pyx":303
+ *         objs = frBbox([pyobj], h, w)[0]
+ *     elif type(pyobj) == list and len(pyobj) > 4:
+ *         objs = frPoly([pyobj], h, w)[0]             # <<<<<<<<<<<<<<
+ *     elif type(pyobj) == dict and 'counts' in pyobj and 'size' in pyobj:
+ *         objs = frUncompressedRLE([pyobj], h, w)[0]
+ */
+    __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_frPoly); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 303, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_10 = PyList_New(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 303, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_10);
+    __Pyx_INCREF(__pyx_v_pyobj);
+    __Pyx_GIVEREF(__pyx_v_pyobj);
+    PyList_SET_ITEM(__pyx_t_10, 0, __pyx_v_pyobj);
+    __pyx_t_4 = NULL;
+    __pyx_t_5 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+      if (likely(__pyx_t_4)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+        __Pyx_INCREF(__pyx_t_4);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_3, function);
+        __pyx_t_5 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_t_10, __pyx_v_h, __pyx_v_w};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 303, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_t_10, __pyx_v_h, __pyx_v_w};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 303, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_6 = PyTuple_New(3+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 303, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      if (__pyx_t_4) {
+        __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL;
+      }
+      __Pyx_GIVEREF(__pyx_t_10);
+      PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, __pyx_t_10);
+      __Pyx_INCREF(__pyx_v_h);
+      __Pyx_GIVEREF(__pyx_v_h);
+      PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_h);
+      __Pyx_INCREF(__pyx_v_w);
+      __Pyx_GIVEREF(__pyx_v_w);
+      PyTuple_SET_ITEM(__pyx_t_6, 2+__pyx_t_5, __pyx_v_w);
+      __pyx_t_10 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 303, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 303, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_v_objs = __pyx_t_3;
+    __pyx_t_3 = 0;
+
+    /* "pycocotools/_mask.pyx":302
+ *     elif type(pyobj) == list and len(pyobj) == 4:
+ *         objs = frBbox([pyobj], h, w)[0]
+ *     elif type(pyobj) == list and len(pyobj) > 4:             # <<<<<<<<<<<<<<
+ *         objs = frPoly([pyobj], h, w)[0]
+ *     elif type(pyobj) == dict and 'counts' in pyobj and 'size' in pyobj:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pycocotools/_mask.pyx":304
+ *     elif type(pyobj) == list and len(pyobj) > 4:
+ *         objs = frPoly([pyobj], h, w)[0]
+ *     elif type(pyobj) == dict and 'counts' in pyobj and 'size' in pyobj:             # <<<<<<<<<<<<<<
+ *         objs = frUncompressedRLE([pyobj], h, w)[0]
+ *     else:
+ */
+  __pyx_t_3 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_pyobj)), ((PyObject *)(&PyDict_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 304, __pyx_L1_error)
+  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 304, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (__pyx_t_7) {
+  } else {
+    __pyx_t_2 = __pyx_t_7;
+    goto __pyx_L16_bool_binop_done;
+  }
+  __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_n_s_counts, __pyx_v_pyobj, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 304, __pyx_L1_error)
+  __pyx_t_9 = (__pyx_t_7 != 0);
+  if (__pyx_t_9) {
+  } else {
+    __pyx_t_2 = __pyx_t_9;
+    goto __pyx_L16_bool_binop_done;
+  }
+  __pyx_t_9 = (__Pyx_PySequence_ContainsTF(__pyx_n_s_size, __pyx_v_pyobj, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 304, __pyx_L1_error)
+  __pyx_t_7 = (__pyx_t_9 != 0);
+  __pyx_t_2 = __pyx_t_7;
+  __pyx_L16_bool_binop_done:;
+  if (__pyx_t_2) {
+
+    /* "pycocotools/_mask.pyx":305
+ *         objs = frPoly([pyobj], h, w)[0]
+ *     elif type(pyobj) == dict and 'counts' in pyobj and 'size' in pyobj:
+ *         objs = frUncompressedRLE([pyobj], h, w)[0]             # <<<<<<<<<<<<<<
+ *     else:
+ *         raise Exception('input type is not supported.')
+ */
+    __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_frUncompressedRLE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 305, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 305, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_INCREF(__pyx_v_pyobj);
+    __Pyx_GIVEREF(__pyx_v_pyobj);
+    PyList_SET_ITEM(__pyx_t_6, 0, __pyx_v_pyobj);
+    __pyx_t_10 = NULL;
+    __pyx_t_5 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+      __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_1);
+      if (likely(__pyx_t_10)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+        __Pyx_INCREF(__pyx_t_10);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_1, function);
+        __pyx_t_5 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_1)) {
+      PyObject *__pyx_temp[4] = {__pyx_t_10, __pyx_t_6, __pyx_v_h, __pyx_v_w};
+      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 305, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
+      PyObject *__pyx_temp[4] = {__pyx_t_10, __pyx_t_6, __pyx_v_h, __pyx_v_w};
+      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 305, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(3+__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 305, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      if (__pyx_t_10) {
+        __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_10); __pyx_t_10 = NULL;
+      }
+      __Pyx_GIVEREF(__pyx_t_6);
+      PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_5, __pyx_t_6);
+      __Pyx_INCREF(__pyx_v_h);
+      __Pyx_GIVEREF(__pyx_v_h);
+      PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_5, __pyx_v_h);
+      __Pyx_INCREF(__pyx_v_w);
+      __Pyx_GIVEREF(__pyx_v_w);
+      PyTuple_SET_ITEM(__pyx_t_4, 2+__pyx_t_5, __pyx_v_w);
+      __pyx_t_6 = 0;
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 305, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 305, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_v_objs = __pyx_t_1;
+    __pyx_t_1 = 0;
+
+    /* "pycocotools/_mask.pyx":304
+ *     elif type(pyobj) == list and len(pyobj) > 4:
+ *         objs = frPoly([pyobj], h, w)[0]
+ *     elif type(pyobj) == dict and 'counts' in pyobj and 'size' in pyobj:             # <<<<<<<<<<<<<<
+ *         objs = frUncompressedRLE([pyobj], h, w)[0]
+ *     else:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pycocotools/_mask.pyx":307
+ *         objs = frUncompressedRLE([pyobj], h, w)[0]
+ *     else:
+ *         raise Exception('input type is not supported.')             # <<<<<<<<<<<<<<
+ *     return objs
+ */
+  /*else*/ {
+    __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 307, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_Raise(__pyx_t_1, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __PYX_ERR(0, 307, __pyx_L1_error)
+  }
+  __pyx_L3:;
+
+  /* "pycocotools/_mask.pyx":308
+ *     else:
+ *         raise Exception('input type is not supported.')
+ *     return objs             # <<<<<<<<<<<<<<
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_objs);
+  __pyx_r = __pyx_v_objs;
+  goto __pyx_L0;
+
+  /* "pycocotools/_mask.pyx":288
+ *     return objs
+ * 
+ * def frPyObjects(pyobj, h, w):             # <<<<<<<<<<<<<<
+ *     # encode rle from a list of python objects
+ *     if type(pyobj) == np.ndarray:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("pycocotools._mask.frPyObjects", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_objs);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":197
+ *         # experimental exception made for __getbuffer__ and __releasebuffer__
+ *         # -- the details of this may change.
+ *         def __getbuffer__(ndarray self, Py_buffer* info, int flags):             # <<<<<<<<<<<<<<
+ *             # This implementation of getbuffer is geared towards Cython
+ *             # requirements, and does not yet fullfill the PEP.
+ */
+
+/* Python wrapper */
+static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
+static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
+  int __pyx_v_copy_shape;
+  int __pyx_v_i;
+  int __pyx_v_ndim;
+  int __pyx_v_endian_detector;
+  int __pyx_v_little_endian;
+  int __pyx_v_t;
+  char *__pyx_v_f;
+  PyArray_Descr *__pyx_v_descr = 0;
+  int __pyx_v_offset;
+  int __pyx_v_hasfields;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  char *__pyx_t_7;
+  __Pyx_RefNannySetupContext("__getbuffer__", 0);
+  if (__pyx_v_info != NULL) {
+    __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(__pyx_v_info->obj);
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":203
+ *             # of flags
+ * 
+ *             if info == NULL: return             # <<<<<<<<<<<<<<
+ * 
+ *             cdef int copy_shape, i, ndim
+ */
+  __pyx_t_1 = ((__pyx_v_info == NULL) != 0);
+  if (__pyx_t_1) {
+    __pyx_r = 0;
+    goto __pyx_L0;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":206
+ * 
+ *             cdef int copy_shape, i, ndim
+ *             cdef int endian_detector = 1             # <<<<<<<<<<<<<<
+ *             cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)
+ * 
+ */
+  __pyx_v_endian_detector = 1;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":207
+ *             cdef int copy_shape, i, ndim
+ *             cdef int endian_detector = 1
+ *             cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)             # <<<<<<<<<<<<<<
+ * 
+ *             ndim = PyArray_NDIM(self)
+ */
+  __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":209
+ *             cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)
+ * 
+ *             ndim = PyArray_NDIM(self)             # <<<<<<<<<<<<<<
+ * 
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ */
+  __pyx_v_ndim = PyArray_NDIM(__pyx_v_self);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":211
+ *             ndim = PyArray_NDIM(self)
+ * 
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
+ *                 copy_shape = 1
+ *             else:
+ */
+  __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":212
+ * 
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ *                 copy_shape = 1             # <<<<<<<<<<<<<<
+ *             else:
+ *                 copy_shape = 0
+ */
+    __pyx_v_copy_shape = 1;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":211
+ *             ndim = PyArray_NDIM(self)
+ * 
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
+ *                 copy_shape = 1
+ *             else:
+ */
+    goto __pyx_L4;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":214
+ *                 copy_shape = 1
+ *             else:
+ *                 copy_shape = 0             # <<<<<<<<<<<<<<
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
+ */
+  /*else*/ {
+    __pyx_v_copy_shape = 0;
+  }
+  __pyx_L4:;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216
+ *                 copy_shape = 0
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ */
+  __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L6_bool_binop_done;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":217
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):             # <<<<<<<<<<<<<<
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ * 
+ */
+  __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_C_CONTIGUOUS) != 0)) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L6_bool_binop_done:;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216
+ *                 copy_shape = 0
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ */
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":218
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")             # <<<<<<<<<<<<<<
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__19, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 218, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(1, 218, __pyx_L1_error)
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216
+ *                 copy_shape = 0
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ */
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ */
+  __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L9_bool_binop_done;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":221
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):             # <<<<<<<<<<<<<<
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ * 
+ */
+  __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_F_CONTIGUOUS) != 0)) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L9_bool_binop_done:;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ */
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":222
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")             # <<<<<<<<<<<<<<
+ * 
+ *             info.buf = PyArray_DATA(self)
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__20, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 222, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(1, 222, __pyx_L1_error)
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ */
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":224
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ * 
+ *             info.buf = PyArray_DATA(self)             # <<<<<<<<<<<<<<
+ *             info.ndim = ndim
+ *             if copy_shape:
+ */
+  __pyx_v_info->buf = PyArray_DATA(__pyx_v_self);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":225
+ * 
+ *             info.buf = PyArray_DATA(self)
+ *             info.ndim = ndim             # <<<<<<<<<<<<<<
+ *             if copy_shape:
+ *                 # Allocate new buffer for strides and shape info.
+ */
+  __pyx_v_info->ndim = __pyx_v_ndim;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":226
+ *             info.buf = PyArray_DATA(self)
+ *             info.ndim = ndim
+ *             if copy_shape:             # <<<<<<<<<<<<<<
+ *                 # Allocate new buffer for strides and shape info.
+ *                 # This is allocated as one block, strides first.
+ */
+  __pyx_t_1 = (__pyx_v_copy_shape != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":229
+ *                 # Allocate new buffer for strides and shape info.
+ *                 # This is allocated as one block, strides first.
+ *                 info.strides = <Py_ssize_t*>stdlib.malloc(sizeof(Py_ssize_t) * <size_t>ndim * 2)             # <<<<<<<<<<<<<<
+ *                 info.shape = info.strides + ndim
+ *                 for i in range(ndim):
+ */
+    __pyx_v_info->strides = ((Py_ssize_t *)malloc((((sizeof(Py_ssize_t)) * ((size_t)__pyx_v_ndim)) * 2)));
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":230
+ *                 # This is allocated as one block, strides first.
+ *                 info.strides = <Py_ssize_t*>stdlib.malloc(sizeof(Py_ssize_t) * <size_t>ndim * 2)
+ *                 info.shape = info.strides + ndim             # <<<<<<<<<<<<<<
+ *                 for i in range(ndim):
+ *                     info.strides[i] = PyArray_STRIDES(self)[i]
+ */
+    __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim);
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":231
+ *                 info.strides = <Py_ssize_t*>stdlib.malloc(sizeof(Py_ssize_t) * <size_t>ndim * 2)
+ *                 info.shape = info.strides + ndim
+ *                 for i in range(ndim):             # <<<<<<<<<<<<<<
+ *                     info.strides[i] = PyArray_STRIDES(self)[i]
+ *                     info.shape[i] = PyArray_DIMS(self)[i]
+ */
+    __pyx_t_4 = __pyx_v_ndim;
+    for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
+      __pyx_v_i = __pyx_t_5;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":232
+ *                 info.shape = info.strides + ndim
+ *                 for i in range(ndim):
+ *                     info.strides[i] = PyArray_STRIDES(self)[i]             # <<<<<<<<<<<<<<
+ *                     info.shape[i] = PyArray_DIMS(self)[i]
+ *             else:
+ */
+      (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]);
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":233
+ *                 for i in range(ndim):
+ *                     info.strides[i] = PyArray_STRIDES(self)[i]
+ *                     info.shape[i] = PyArray_DIMS(self)[i]             # <<<<<<<<<<<<<<
+ *             else:
+ *                 info.strides = <Py_ssize_t*>PyArray_STRIDES(self)
+ */
+      (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]);
+    }
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":226
+ *             info.buf = PyArray_DATA(self)
+ *             info.ndim = ndim
+ *             if copy_shape:             # <<<<<<<<<<<<<<
+ *                 # Allocate new buffer for strides and shape info.
+ *                 # This is allocated as one block, strides first.
+ */
+    goto __pyx_L11;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":235
+ *                     info.shape[i] = PyArray_DIMS(self)[i]
+ *             else:
+ *                 info.strides = <Py_ssize_t*>PyArray_STRIDES(self)             # <<<<<<<<<<<<<<
+ *                 info.shape = <Py_ssize_t*>PyArray_DIMS(self)
+ *             info.suboffsets = NULL
+ */
+  /*else*/ {
+    __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self));
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":236
+ *             else:
+ *                 info.strides = <Py_ssize_t*>PyArray_STRIDES(self)
+ *                 info.shape = <Py_ssize_t*>PyArray_DIMS(self)             # <<<<<<<<<<<<<<
+ *             info.suboffsets = NULL
+ *             info.itemsize = PyArray_ITEMSIZE(self)
+ */
+    __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self));
+  }
+  __pyx_L11:;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":237
+ *                 info.strides = <Py_ssize_t*>PyArray_STRIDES(self)
+ *                 info.shape = <Py_ssize_t*>PyArray_DIMS(self)
+ *             info.suboffsets = NULL             # <<<<<<<<<<<<<<
+ *             info.itemsize = PyArray_ITEMSIZE(self)
+ *             info.readonly = not PyArray_ISWRITEABLE(self)
+ */
+  __pyx_v_info->suboffsets = NULL;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":238
+ *                 info.shape = <Py_ssize_t*>PyArray_DIMS(self)
+ *             info.suboffsets = NULL
+ *             info.itemsize = PyArray_ITEMSIZE(self)             # <<<<<<<<<<<<<<
+ *             info.readonly = not PyArray_ISWRITEABLE(self)
+ * 
+ */
+  __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":239
+ *             info.suboffsets = NULL
+ *             info.itemsize = PyArray_ITEMSIZE(self)
+ *             info.readonly = not PyArray_ISWRITEABLE(self)             # <<<<<<<<<<<<<<
+ * 
+ *             cdef int t
+ */
+  __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0));
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":242
+ * 
+ *             cdef int t
+ *             cdef char* f = NULL             # <<<<<<<<<<<<<<
+ *             cdef dtype descr = self.descr
+ *             cdef int offset
+ */
+  __pyx_v_f = NULL;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":243
+ *             cdef int t
+ *             cdef char* f = NULL
+ *             cdef dtype descr = self.descr             # <<<<<<<<<<<<<<
+ *             cdef int offset
+ * 
+ */
+  __pyx_t_3 = ((PyObject *)__pyx_v_self->descr);
+  __Pyx_INCREF(__pyx_t_3);
+  __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":246
+ *             cdef int offset
+ * 
+ *             cdef bint hasfields = PyDataType_HASFIELDS(descr)             # <<<<<<<<<<<<<<
+ * 
+ *             if not hasfields and not copy_shape:
+ */
+  __pyx_v_hasfields = PyDataType_HASFIELDS(__pyx_v_descr);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":248
+ *             cdef bint hasfields = PyDataType_HASFIELDS(descr)
+ * 
+ *             if not hasfields and not copy_shape:             # <<<<<<<<<<<<<<
+ *                 # do not call releasebuffer
+ *                 info.obj = None
+ */
+  __pyx_t_2 = ((!(__pyx_v_hasfields != 0)) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L15_bool_binop_done;
+  }
+  __pyx_t_2 = ((!(__pyx_v_copy_shape != 0)) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L15_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":250
+ *             if not hasfields and not copy_shape:
+ *                 # do not call releasebuffer
+ *                 info.obj = None             # <<<<<<<<<<<<<<
+ *             else:
+ *                 # need to call releasebuffer
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __Pyx_GOTREF(__pyx_v_info->obj);
+    __Pyx_DECREF(__pyx_v_info->obj);
+    __pyx_v_info->obj = Py_None;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":248
+ *             cdef bint hasfields = PyDataType_HASFIELDS(descr)
+ * 
+ *             if not hasfields and not copy_shape:             # <<<<<<<<<<<<<<
+ *                 # do not call releasebuffer
+ *                 info.obj = None
+ */
+    goto __pyx_L14;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":253
+ *             else:
+ *                 # need to call releasebuffer
+ *                 info.obj = self             # <<<<<<<<<<<<<<
+ * 
+ *             if not hasfields:
+ */
+  /*else*/ {
+    __Pyx_INCREF(((PyObject *)__pyx_v_self));
+    __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+    __Pyx_GOTREF(__pyx_v_info->obj);
+    __Pyx_DECREF(__pyx_v_info->obj);
+    __pyx_v_info->obj = ((PyObject *)__pyx_v_self);
+  }
+  __pyx_L14:;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":255
+ *                 info.obj = self
+ * 
+ *             if not hasfields:             # <<<<<<<<<<<<<<
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ */
+  __pyx_t_1 = ((!(__pyx_v_hasfields != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":256
+ * 
+ *             if not hasfields:
+ *                 t = descr.type_num             # <<<<<<<<<<<<<<
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ */
+    __pyx_t_4 = __pyx_v_descr->type_num;
+    __pyx_v_t = __pyx_t_4;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257
+ *             if not hasfields:
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")
+ */
+    __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0);
+    if (!__pyx_t_2) {
+      goto __pyx_L20_next_or;
+    } else {
+    }
+    __pyx_t_2 = (__pyx_v_little_endian != 0);
+    if (!__pyx_t_2) {
+    } else {
+      __pyx_t_1 = __pyx_t_2;
+      goto __pyx_L19_bool_binop_done;
+    }
+    __pyx_L20_next_or:;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":258
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ *                     (descr.byteorder == c'<' and not little_endian)):             # <<<<<<<<<<<<<<
+ *                     raise ValueError(u"Non-native byte order not supported")
+ *                 if   t == NPY_BYTE:        f = "b"
+ */
+    __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0);
+    if (__pyx_t_2) {
+    } else {
+      __pyx_t_1 = __pyx_t_2;
+      goto __pyx_L19_bool_binop_done;
+    }
+    __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0);
+    __pyx_t_1 = __pyx_t_2;
+    __pyx_L19_bool_binop_done:;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257
+ *             if not hasfields:
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")
+ */
+    if (__pyx_t_1) {
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":259
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
+ *                 if   t == NPY_BYTE:        f = "b"
+ *                 elif t == NPY_UBYTE:       f = "B"
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 259, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(1, 259, __pyx_L1_error)
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257
+ *             if not hasfields:
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")
+ */
+    }
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":260
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")
+ *                 if   t == NPY_BYTE:        f = "b"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_UBYTE:       f = "B"
+ *                 elif t == NPY_SHORT:       f = "h"
+ */
+    switch (__pyx_v_t) {
+      case NPY_BYTE:
+      __pyx_v_f = ((char *)"b");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":261
+ *                     raise ValueError(u"Non-native byte order not supported")
+ *                 if   t == NPY_BYTE:        f = "b"
+ *                 elif t == NPY_UBYTE:       f = "B"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_SHORT:       f = "h"
+ *                 elif t == NPY_USHORT:      f = "H"
+ */
+      case NPY_UBYTE:
+      __pyx_v_f = ((char *)"B");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":262
+ *                 if   t == NPY_BYTE:        f = "b"
+ *                 elif t == NPY_UBYTE:       f = "B"
+ *                 elif t == NPY_SHORT:       f = "h"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_USHORT:      f = "H"
+ *                 elif t == NPY_INT:         f = "i"
+ */
+      case NPY_SHORT:
+      __pyx_v_f = ((char *)"h");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":263
+ *                 elif t == NPY_UBYTE:       f = "B"
+ *                 elif t == NPY_SHORT:       f = "h"
+ *                 elif t == NPY_USHORT:      f = "H"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_INT:         f = "i"
+ *                 elif t == NPY_UINT:        f = "I"
+ */
+      case NPY_USHORT:
+      __pyx_v_f = ((char *)"H");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":264
+ *                 elif t == NPY_SHORT:       f = "h"
+ *                 elif t == NPY_USHORT:      f = "H"
+ *                 elif t == NPY_INT:         f = "i"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_UINT:        f = "I"
+ *                 elif t == NPY_LONG:        f = "l"
+ */
+      case NPY_INT:
+      __pyx_v_f = ((char *)"i");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":265
+ *                 elif t == NPY_USHORT:      f = "H"
+ *                 elif t == NPY_INT:         f = "i"
+ *                 elif t == NPY_UINT:        f = "I"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_LONG:        f = "l"
+ *                 elif t == NPY_ULONG:       f = "L"
+ */
+      case NPY_UINT:
+      __pyx_v_f = ((char *)"I");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":266
+ *                 elif t == NPY_INT:         f = "i"
+ *                 elif t == NPY_UINT:        f = "I"
+ *                 elif t == NPY_LONG:        f = "l"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_ULONG:       f = "L"
+ *                 elif t == NPY_LONGLONG:    f = "q"
+ */
+      case NPY_LONG:
+      __pyx_v_f = ((char *)"l");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":267
+ *                 elif t == NPY_UINT:        f = "I"
+ *                 elif t == NPY_LONG:        f = "l"
+ *                 elif t == NPY_ULONG:       f = "L"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_LONGLONG:    f = "q"
+ *                 elif t == NPY_ULONGLONG:   f = "Q"
+ */
+      case NPY_ULONG:
+      __pyx_v_f = ((char *)"L");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":268
+ *                 elif t == NPY_LONG:        f = "l"
+ *                 elif t == NPY_ULONG:       f = "L"
+ *                 elif t == NPY_LONGLONG:    f = "q"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_ULONGLONG:   f = "Q"
+ *                 elif t == NPY_FLOAT:       f = "f"
+ */
+      case NPY_LONGLONG:
+      __pyx_v_f = ((char *)"q");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":269
+ *                 elif t == NPY_ULONG:       f = "L"
+ *                 elif t == NPY_LONGLONG:    f = "q"
+ *                 elif t == NPY_ULONGLONG:   f = "Q"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_FLOAT:       f = "f"
+ *                 elif t == NPY_DOUBLE:      f = "d"
+ */
+      case NPY_ULONGLONG:
+      __pyx_v_f = ((char *)"Q");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":270
+ *                 elif t == NPY_LONGLONG:    f = "q"
+ *                 elif t == NPY_ULONGLONG:   f = "Q"
+ *                 elif t == NPY_FLOAT:       f = "f"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_DOUBLE:      f = "d"
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"
+ */
+      case NPY_FLOAT:
+      __pyx_v_f = ((char *)"f");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":271
+ *                 elif t == NPY_ULONGLONG:   f = "Q"
+ *                 elif t == NPY_FLOAT:       f = "f"
+ *                 elif t == NPY_DOUBLE:      f = "d"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"
+ *                 elif t == NPY_CFLOAT:      f = "Zf"
+ */
+      case NPY_DOUBLE:
+      __pyx_v_f = ((char *)"d");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":272
+ *                 elif t == NPY_FLOAT:       f = "f"
+ *                 elif t == NPY_DOUBLE:      f = "d"
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_CFLOAT:      f = "Zf"
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"
+ */
+      case NPY_LONGDOUBLE:
+      __pyx_v_f = ((char *)"g");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":273
+ *                 elif t == NPY_DOUBLE:      f = "d"
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"
+ *                 elif t == NPY_CFLOAT:      f = "Zf"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"
+ *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
+ */
+      case NPY_CFLOAT:
+      __pyx_v_f = ((char *)"Zf");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":274
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"
+ *                 elif t == NPY_CFLOAT:      f = "Zf"
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
+ *                 elif t == NPY_OBJECT:      f = "O"
+ */
+      case NPY_CDOUBLE:
+      __pyx_v_f = ((char *)"Zd");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":275
+ *                 elif t == NPY_CFLOAT:      f = "Zf"
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"
+ *                 elif t == NPY_CLONGDOUBLE: f = "Zg"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_OBJECT:      f = "O"
+ *                 else:
+ */
+      case NPY_CLONGDOUBLE:
+      __pyx_v_f = ((char *)"Zg");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":276
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"
+ *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
+ *                 elif t == NPY_OBJECT:      f = "O"             # <<<<<<<<<<<<<<
+ *                 else:
+ *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ */
+      case NPY_OBJECT:
+      __pyx_v_f = ((char *)"O");
+      break;
+      default:
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":278
+ *                 elif t == NPY_OBJECT:      f = "O"
+ *                 else:
+ *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)             # <<<<<<<<<<<<<<
+ *                 info.format = f
+ *                 return
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 278, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_6 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 278, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 278, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_GIVEREF(__pyx_t_6);
+      PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6);
+      __pyx_t_6 = 0;
+      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 278, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_Raise(__pyx_t_6, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __PYX_ERR(1, 278, __pyx_L1_error)
+      break;
+    }
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":279
+ *                 else:
+ *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ *                 info.format = f             # <<<<<<<<<<<<<<
+ *                 return
+ *             else:
+ */
+    __pyx_v_info->format = __pyx_v_f;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":280
+ *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ *                 info.format = f
+ *                 return             # <<<<<<<<<<<<<<
+ *             else:
+ *                 info.format = <char*>stdlib.malloc(_buffer_format_string_len)
+ */
+    __pyx_r = 0;
+    goto __pyx_L0;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":255
+ *                 info.obj = self
+ * 
+ *             if not hasfields:             # <<<<<<<<<<<<<<
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ */
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":282
+ *                 return
+ *             else:
+ *                 info.format = <char*>stdlib.malloc(_buffer_format_string_len)             # <<<<<<<<<<<<<<
+ *                 info.format[0] = c'^' # Native data types, manual alignment
+ *                 offset = 0
+ */
+  /*else*/ {
+    __pyx_v_info->format = ((char *)malloc(0xFF));
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":283
+ *             else:
+ *                 info.format = <char*>stdlib.malloc(_buffer_format_string_len)
+ *                 info.format[0] = c'^' # Native data types, manual alignment             # <<<<<<<<<<<<<<
+ *                 offset = 0
+ *                 f = _util_dtypestring(descr, info.format + 1,
+ */
+    (__pyx_v_info->format[0]) = '^';
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":284
+ *                 info.format = <char*>stdlib.malloc(_buffer_format_string_len)
+ *                 info.format[0] = c'^' # Native data types, manual alignment
+ *                 offset = 0             # <<<<<<<<<<<<<<
+ *                 f = _util_dtypestring(descr, info.format + 1,
+ *                                       info.format + _buffer_format_string_len,
+ */
+    __pyx_v_offset = 0;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":285
+ *                 info.format[0] = c'^' # Native data types, manual alignment
+ *                 offset = 0
+ *                 f = _util_dtypestring(descr, info.format + 1,             # <<<<<<<<<<<<<<
+ *                                       info.format + _buffer_format_string_len,
+ *                                       &offset)
+ */
+    __pyx_t_7 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_7 == NULL)) __PYX_ERR(1, 285, __pyx_L1_error)
+    __pyx_v_f = __pyx_t_7;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":288
+ *                                       info.format + _buffer_format_string_len,
+ *                                       &offset)
+ *                 f[0] = c'\0' # Terminate format string             # <<<<<<<<<<<<<<
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):
+ */
+    (__pyx_v_f[0]) = '\x00';
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":197
+ *         # experimental exception made for __getbuffer__ and __releasebuffer__
+ *         # -- the details of this may change.
+ *         def __getbuffer__(ndarray self, Py_buffer* info, int flags):             # <<<<<<<<<<<<<<
+ *             # This implementation of getbuffer is geared towards Cython
+ *             # requirements, and does not yet fullfill the PEP.
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  if (__pyx_v_info != NULL && __pyx_v_info->obj != NULL) {
+    __Pyx_GOTREF(__pyx_v_info->obj);
+    __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = NULL;
+  }
+  goto __pyx_L2;
+  __pyx_L0:;
+  if (__pyx_v_info != NULL && __pyx_v_info->obj == Py_None) {
+    __Pyx_GOTREF(Py_None);
+    __Pyx_DECREF(Py_None); __pyx_v_info->obj = NULL;
+  }
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_descr);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":290
+ *                 f[0] = c'\0' # Terminate format string
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):             # <<<<<<<<<<<<<<
+ *             if PyArray_HASFIELDS(self):
+ *                 stdlib.free(info.format)
+ */
+
+/* Python wrapper */
+static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/
+static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0);
+  __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) {
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("__releasebuffer__", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":291
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):
+ *             if PyArray_HASFIELDS(self):             # <<<<<<<<<<<<<<
+ *                 stdlib.free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ */
+  __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":292
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):
+ *             if PyArray_HASFIELDS(self):
+ *                 stdlib.free(info.format)             # <<<<<<<<<<<<<<
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ *                 stdlib.free(info.strides)
+ */
+    free(__pyx_v_info->format);
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":291
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):
+ *             if PyArray_HASFIELDS(self):             # <<<<<<<<<<<<<<
+ *                 stdlib.free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ */
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":293
+ *             if PyArray_HASFIELDS(self):
+ *                 stdlib.free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
+ *                 stdlib.free(info.strides)
+ *                 # info.shape was stored after info.strides in the same block
+ */
+  __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":294
+ *                 stdlib.free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ *                 stdlib.free(info.strides)             # <<<<<<<<<<<<<<
+ *                 # info.shape was stored after info.strides in the same block
+ * 
+ */
+    free(__pyx_v_info->strides);
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":293
+ *             if PyArray_HASFIELDS(self):
+ *                 stdlib.free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
+ *                 stdlib.free(info.strides)
+ *                 # info.shape was stored after info.strides in the same block
+ */
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":290
+ *                 f[0] = c'\0' # Terminate format string
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):             # <<<<<<<<<<<<<<
+ *             if PyArray_HASFIELDS(self):
+ *                 stdlib.free(info.format)
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":770
+ * ctypedef npy_cdouble     complex_t
+ * 
+ * cdef inline object PyArray_MultiIterNew1(a):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(1, <void*>a)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":771
+ * 
+ * cdef inline object PyArray_MultiIterNew1(a):
+ *     return PyArray_MultiIterNew(1, <void*>a)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew2(a, b):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 771, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":770
+ * ctypedef npy_cdouble     complex_t
+ * 
+ * cdef inline object PyArray_MultiIterNew1(a):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(1, <void*>a)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":773
+ *     return PyArray_MultiIterNew(1, <void*>a)
+ * 
+ * cdef inline object PyArray_MultiIterNew2(a, b):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(2, <void*>a, <void*>b)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":774
+ * 
+ * cdef inline object PyArray_MultiIterNew2(a, b):
+ *     return PyArray_MultiIterNew(2, <void*>a, <void*>b)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew3(a, b, c):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 774, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":773
+ *     return PyArray_MultiIterNew(1, <void*>a)
+ * 
+ * cdef inline object PyArray_MultiIterNew2(a, b):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(2, <void*>a, <void*>b)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":776
+ *     return PyArray_MultiIterNew(2, <void*>a, <void*>b)
+ * 
+ * cdef inline object PyArray_MultiIterNew3(a, b, c):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":777
+ * 
+ * cdef inline object PyArray_MultiIterNew3(a, b, c):
+ *     return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew4(a, b, c, d):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 777, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":776
+ *     return PyArray_MultiIterNew(2, <void*>a, <void*>b)
+ * 
+ * cdef inline object PyArray_MultiIterNew3(a, b, c):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":779
+ *     return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
+ * 
+ * cdef inline object PyArray_MultiIterNew4(a, b, c, d):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":780
+ * 
+ * cdef inline object PyArray_MultiIterNew4(a, b, c, d):
+ *     return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 780, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":779
+ *     return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
+ * 
+ * cdef inline object PyArray_MultiIterNew4(a, b, c, d):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":782
+ *     return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
+ * 
+ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":783
+ * 
+ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
+ *     return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 783, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":782
+ *     return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
+ * 
+ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":785
+ *     return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
+ * 
+ * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:             # <<<<<<<<<<<<<<
+ *     # Recursive utility function used in __getbuffer__ to get format
+ *     # string. The new location in the format string is returned.
+ */
+
+static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) {
+  PyArray_Descr *__pyx_v_child = 0;
+  int __pyx_v_endian_detector;
+  int __pyx_v_little_endian;
+  PyObject *__pyx_v_fields = 0;
+  PyObject *__pyx_v_childname = NULL;
+  PyObject *__pyx_v_new_offset = NULL;
+  PyObject *__pyx_v_t = NULL;
+  char *__pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  Py_ssize_t __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  int __pyx_t_6;
+  int __pyx_t_7;
+  long __pyx_t_8;
+  char *__pyx_t_9;
+  __Pyx_RefNannySetupContext("_util_dtypestring", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":790
+ * 
+ *     cdef dtype child
+ *     cdef int endian_detector = 1             # <<<<<<<<<<<<<<
+ *     cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)
+ *     cdef tuple fields
+ */
+  __pyx_v_endian_detector = 1;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":791
+ *     cdef dtype child
+ *     cdef int endian_detector = 1
+ *     cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)             # <<<<<<<<<<<<<<
+ *     cdef tuple fields
+ * 
+ */
+  __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":794
+ *     cdef tuple fields
+ * 
+ *     for childname in descr.names:             # <<<<<<<<<<<<<<
+ *         fields = descr.fields[childname]
+ *         child, new_offset = fields
+ */
+  if (unlikely(__pyx_v_descr->names == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+    __PYX_ERR(1, 794, __pyx_L1_error)
+  }
+  __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
+  for (;;) {
+    if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 794, __pyx_L1_error)
+    #else
+    __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 794, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    #endif
+    __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":795
+ * 
+ *     for childname in descr.names:
+ *         fields = descr.fields[childname]             # <<<<<<<<<<<<<<
+ *         child, new_offset = fields
+ * 
+ */
+    if (unlikely(__pyx_v_descr->fields == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(1, 795, __pyx_L1_error)
+    }
+    __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 795, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 795, __pyx_L1_error)
+    __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3));
+    __pyx_t_3 = 0;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":796
+ *     for childname in descr.names:
+ *         fields = descr.fields[childname]
+ *         child, new_offset = fields             # <<<<<<<<<<<<<<
+ * 
+ *         if (end - f) - <int>(new_offset - offset[0]) < 15:
+ */
+    if (likely(__pyx_v_fields != Py_None)) {
+      PyObject* sequence = __pyx_v_fields;
+      #if !CYTHON_COMPILING_IN_PYPY
+      Py_ssize_t size = Py_SIZE(sequence);
+      #else
+      Py_ssize_t size = PySequence_Size(sequence);
+      #endif
+      if (unlikely(size != 2)) {
+        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+        __PYX_ERR(1, 796, __pyx_L1_error)
+      }
+      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); 
+      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); 
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_4);
+      #else
+      __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 796, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 796, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      #endif
+    } else {
+      __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 796, __pyx_L1_error)
+    }
+    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 796, __pyx_L1_error)
+    __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3));
+    __pyx_t_3 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":798
+ *         child, new_offset = fields
+ * 
+ *         if (end - f) - <int>(new_offset - offset[0]) < 15:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 798, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 798, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 798, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0);
+    if (__pyx_t_6) {
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":799
+ * 
+ *         if (end - f) - <int>(new_offset - offset[0]) < 15:
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")             # <<<<<<<<<<<<<<
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 799, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(1, 799, __pyx_L1_error)
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":798
+ *         child, new_offset = fields
+ * 
+ *         if (end - f) - <int>(new_offset - offset[0]) < 15:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ */
+    }
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")
+ */
+    __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0);
+    if (!__pyx_t_7) {
+      goto __pyx_L8_next_or;
+    } else {
+    }
+    __pyx_t_7 = (__pyx_v_little_endian != 0);
+    if (!__pyx_t_7) {
+    } else {
+      __pyx_t_6 = __pyx_t_7;
+      goto __pyx_L7_bool_binop_done;
+    }
+    __pyx_L8_next_or:;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":802
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or
+ *             (child.byteorder == c'<' and not little_endian)):             # <<<<<<<<<<<<<<
+ *             raise ValueError(u"Non-native byte order not supported")
+ *             # One could encode it in the format string and have Cython
+ */
+    __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0);
+    if (__pyx_t_7) {
+    } else {
+      __pyx_t_6 = __pyx_t_7;
+      goto __pyx_L7_bool_binop_done;
+    }
+    __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0);
+    __pyx_t_6 = __pyx_t_7;
+    __pyx_L7_bool_binop_done:;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")
+ */
+    if (__pyx_t_6) {
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":803
+ *         if ((child.byteorder == c'>' and little_endian) or
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
+ *             # One could encode it in the format string and have Cython
+ *             # complain instead, BUT: < and > in format strings also imply
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 803, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(1, 803, __pyx_L1_error)
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")
+ */
+    }
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":813
+ * 
+ *         # Output padding bytes
+ *         while offset[0] < new_offset:             # <<<<<<<<<<<<<<
+ *             f[0] = 120 # "x"; pad byte
+ *             f += 1
+ */
+    while (1) {
+      __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 813, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 813, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 813, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (!__pyx_t_6) break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":814
+ *         # Output padding bytes
+ *         while offset[0] < new_offset:
+ *             f[0] = 120 # "x"; pad byte             # <<<<<<<<<<<<<<
+ *             f += 1
+ *             offset[0] += 1
+ */
+      (__pyx_v_f[0]) = 0x78;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":815
+ *         while offset[0] < new_offset:
+ *             f[0] = 120 # "x"; pad byte
+ *             f += 1             # <<<<<<<<<<<<<<
+ *             offset[0] += 1
+ * 
+ */
+      __pyx_v_f = (__pyx_v_f + 1);
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":816
+ *             f[0] = 120 # "x"; pad byte
+ *             f += 1
+ *             offset[0] += 1             # <<<<<<<<<<<<<<
+ * 
+ *         offset[0] += child.itemsize
+ */
+      __pyx_t_8 = 0;
+      (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1);
+    }
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":818
+ *             offset[0] += 1
+ * 
+ *         offset[0] += child.itemsize             # <<<<<<<<<<<<<<
+ * 
+ *         if not PyDataType_HASFIELDS(child):
+ */
+    __pyx_t_8 = 0;
+    (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize);
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":820
+ *         offset[0] += child.itemsize
+ * 
+ *         if not PyDataType_HASFIELDS(child):             # <<<<<<<<<<<<<<
+ *             t = child.type_num
+ *             if end - f < 5:
+ */
+    __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0);
+    if (__pyx_t_6) {
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":821
+ * 
+ *         if not PyDataType_HASFIELDS(child):
+ *             t = child.type_num             # <<<<<<<<<<<<<<
+ *             if end - f < 5:
+ *                 raise RuntimeError(u"Format string allocated too short.")
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 821, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4);
+      __pyx_t_4 = 0;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":822
+ *         if not PyDataType_HASFIELDS(child):
+ *             t = child.type_num
+ *             if end - f < 5:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(u"Format string allocated too short.")
+ * 
+ */
+      __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0);
+      if (__pyx_t_6) {
+
+        /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":823
+ *             t = child.type_num
+ *             if end - f < 5:
+ *                 raise RuntimeError(u"Format string allocated too short.")             # <<<<<<<<<<<<<<
+ * 
+ *             # Until ticket #99 is fixed, use integers to avoid warnings
+ */
+        __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 823, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __PYX_ERR(1, 823, __pyx_L1_error)
+
+        /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":822
+ *         if not PyDataType_HASFIELDS(child):
+ *             t = child.type_num
+ *             if end - f < 5:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(u"Format string allocated too short.")
+ * 
+ */
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":826
+ * 
+ *             # Until ticket #99 is fixed, use integers to avoid warnings
+ *             if   t == NPY_BYTE:        f[0] =  98 #"b"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 826, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 826, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 826, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 98;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":827
+ *             # Until ticket #99 is fixed, use integers to avoid warnings
+ *             if   t == NPY_BYTE:        f[0] =  98 #"b"
+ *             elif t == NPY_UBYTE:       f[0] =  66 #"B"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 827, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 827, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 827, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 66;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":828
+ *             if   t == NPY_BYTE:        f[0] =  98 #"b"
+ *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"
+ *             elif t == NPY_INT:         f[0] = 105 #"i"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 828, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 828, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 828, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x68;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":829
+ *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_INT:         f[0] = 105 #"i"
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 829, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 829, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 829, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 72;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":830
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"
+ *             elif t == NPY_INT:         f[0] = 105 #"i"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 830, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 830, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 830, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x69;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":831
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"
+ *             elif t == NPY_INT:         f[0] = 105 #"i"
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 831, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 831, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 831, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 73;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":832
+ *             elif t == NPY_INT:         f[0] = 105 #"i"
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 832, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 832, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 832, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x6C;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":833
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 833, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 833, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 833, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 76;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":834
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 834, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 834, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 834, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x71;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":835
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 835, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 835, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 835, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 81;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":836
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 836, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 836, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 836, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x66;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":837
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 837, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 837, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 837, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x64;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":838
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 838, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 838, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 838, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x67;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":839
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf             # <<<<<<<<<<<<<<
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
+ *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 839, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 839, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 839, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 90;
+        (__pyx_v_f[1]) = 0x66;
+        __pyx_v_f = (__pyx_v_f + 1);
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":840
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd             # <<<<<<<<<<<<<<
+ *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
+ *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 840, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 840, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 840, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 90;
+        (__pyx_v_f[1]) = 0x64;
+        __pyx_v_f = (__pyx_v_f + 1);
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":841
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
+ *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg             # <<<<<<<<<<<<<<
+ *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
+ *             else:
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 841, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 841, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 841, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 90;
+        (__pyx_v_f[1]) = 0x67;
+        __pyx_v_f = (__pyx_v_f + 1);
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":842
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
+ *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
+ *             elif t == NPY_OBJECT:      f[0] = 79 #"O"             # <<<<<<<<<<<<<<
+ *             else:
+ *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 842, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 842, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 842, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 79;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":844
+ *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
+ *             else:
+ *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)             # <<<<<<<<<<<<<<
+ *             f += 1
+ *         else:
+ */
+      /*else*/ {
+        __pyx_t_3 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 844, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 844, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GIVEREF(__pyx_t_3);
+        PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
+        __pyx_t_3 = 0;
+        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 844, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __PYX_ERR(1, 844, __pyx_L1_error)
+      }
+      __pyx_L15:;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":845
+ *             else:
+ *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ *             f += 1             # <<<<<<<<<<<<<<
+ *         else:
+ *             # Cython ignores struct boundary information ("T{...}"),
+ */
+      __pyx_v_f = (__pyx_v_f + 1);
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":820
+ *         offset[0] += child.itemsize
+ * 
+ *         if not PyDataType_HASFIELDS(child):             # <<<<<<<<<<<<<<
+ *             t = child.type_num
+ *             if end - f < 5:
+ */
+      goto __pyx_L13;
+    }
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":849
+ *             # Cython ignores struct boundary information ("T{...}"),
+ *             # so don't output it
+ *             f = _util_dtypestring(child, f, end, offset)             # <<<<<<<<<<<<<<
+ *     return f
+ * 
+ */
+    /*else*/ {
+      __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == NULL)) __PYX_ERR(1, 849, __pyx_L1_error)
+      __pyx_v_f = __pyx_t_9;
+    }
+    __pyx_L13:;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":794
+ *     cdef tuple fields
+ * 
+ *     for childname in descr.names:             # <<<<<<<<<<<<<<
+ *         fields = descr.fields[childname]
+ *         child, new_offset = fields
+ */
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":850
+ *             # so don't output it
+ *             f = _util_dtypestring(child, f, end, offset)
+ *     return f             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = __pyx_v_f;
+  goto __pyx_L0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":785
+ *     return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
+ * 
+ * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:             # <<<<<<<<<<<<<<
+ *     # Recursive utility function used in __getbuffer__ to get format
+ *     # string. The new location in the format string is returned.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_child);
+  __Pyx_XDECREF(__pyx_v_fields);
+  __Pyx_XDECREF(__pyx_v_childname);
+  __Pyx_XDECREF(__pyx_v_new_offset);
+  __Pyx_XDECREF(__pyx_v_t);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":966
+ * 
+ * 
+ * cdef inline void set_array_base(ndarray arr, object base):             # <<<<<<<<<<<<<<
+ *      cdef PyObject* baseptr
+ *      if base is None:
+ */
+
+static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) {
+  PyObject *__pyx_v_baseptr;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  __Pyx_RefNannySetupContext("set_array_base", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":968
+ * cdef inline void set_array_base(ndarray arr, object base):
+ *      cdef PyObject* baseptr
+ *      if base is None:             # <<<<<<<<<<<<<<
+ *          baseptr = NULL
+ *      else:
+ */
+  __pyx_t_1 = (__pyx_v_base == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":969
+ *      cdef PyObject* baseptr
+ *      if base is None:
+ *          baseptr = NULL             # <<<<<<<<<<<<<<
+ *      else:
+ *          Py_INCREF(base) # important to do this before decref below!
+ */
+    __pyx_v_baseptr = NULL;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":968
+ * cdef inline void set_array_base(ndarray arr, object base):
+ *      cdef PyObject* baseptr
+ *      if base is None:             # <<<<<<<<<<<<<<
+ *          baseptr = NULL
+ *      else:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":971
+ *          baseptr = NULL
+ *      else:
+ *          Py_INCREF(base) # important to do this before decref below!             # <<<<<<<<<<<<<<
+ *          baseptr = <PyObject*>base
+ *      Py_XDECREF(arr.base)
+ */
+  /*else*/ {
+    Py_INCREF(__pyx_v_base);
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":972
+ *      else:
+ *          Py_INCREF(base) # important to do this before decref below!
+ *          baseptr = <PyObject*>base             # <<<<<<<<<<<<<<
+ *      Py_XDECREF(arr.base)
+ *      arr.base = baseptr
+ */
+    __pyx_v_baseptr = ((PyObject *)__pyx_v_base);
+  }
+  __pyx_L3:;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":973
+ *          Py_INCREF(base) # important to do this before decref below!
+ *          baseptr = <PyObject*>base
+ *      Py_XDECREF(arr.base)             # <<<<<<<<<<<<<<
+ *      arr.base = baseptr
+ * 
+ */
+  Py_XDECREF(__pyx_v_arr->base);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":974
+ *          baseptr = <PyObject*>base
+ *      Py_XDECREF(arr.base)
+ *      arr.base = baseptr             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object get_array_base(ndarray arr):
+ */
+  __pyx_v_arr->base = __pyx_v_baseptr;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":966
+ * 
+ * 
+ * cdef inline void set_array_base(ndarray arr, object base):             # <<<<<<<<<<<<<<
+ *      cdef PyObject* baseptr
+ *      if base is None:
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976
+ *      arr.base = baseptr
+ * 
+ * cdef inline object get_array_base(ndarray arr):             # <<<<<<<<<<<<<<
+ *     if arr.base is NULL:
+ *         return None
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("get_array_base", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":977
+ * 
+ * cdef inline object get_array_base(ndarray arr):
+ *     if arr.base is NULL:             # <<<<<<<<<<<<<<
+ *         return None
+ *     else:
+ */
+  __pyx_t_1 = ((__pyx_v_arr->base == NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":978
+ * cdef inline object get_array_base(ndarray arr):
+ *     if arr.base is NULL:
+ *         return None             # <<<<<<<<<<<<<<
+ *     else:
+ *         return <object>arr.base
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(Py_None);
+    __pyx_r = Py_None;
+    goto __pyx_L0;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":977
+ * 
+ * cdef inline object get_array_base(ndarray arr):
+ *     if arr.base is NULL:             # <<<<<<<<<<<<<<
+ *         return None
+ *     else:
+ */
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":980
+ *         return None
+ *     else:
+ *         return <object>arr.base             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  /*else*/ {
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(((PyObject *)__pyx_v_arr->base));
+    __pyx_r = ((PyObject *)__pyx_v_arr->base);
+    goto __pyx_L0;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976
+ *      arr.base = baseptr
+ * 
+ * cdef inline object get_array_base(ndarray arr):             # <<<<<<<<<<<<<<
+ *     if arr.base is NULL:
+ *         return None
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":985
+ * # Versions of the import_* functions which are more suitable for
+ * # Cython code.
+ * cdef inline int import_array() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_array()
+ */
+
+static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  __Pyx_RefNannySetupContext("import_array", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":986
+ * # Cython code.
+ * cdef inline int import_array() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_array()
+ *     except Exception:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":987
+ * cdef inline int import_array() except -1:
+ *     try:
+ *         _import_array()             # <<<<<<<<<<<<<<
+ *     except Exception:
+ *         raise ImportError("numpy.core.multiarray failed to import")
+ */
+      __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(1, 987, __pyx_L3_error)
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":986
+ * # Cython code.
+ * cdef inline int import_array() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_array()
+ *     except Exception:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L10_try_end;
+    __pyx_L3_error:;
+    __Pyx_PyThreadState_assign
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":988
+ *     try:
+ *         _import_array()
+ *     except Exception:             # <<<<<<<<<<<<<<
+ *         raise ImportError("numpy.core.multiarray failed to import")
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_4) {
+      __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 988, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":989
+ *         _import_array()
+ *     except Exception:
+ *         raise ImportError("numpy.core.multiarray failed to import")             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline int import_umath() except -1:
+ */
+      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 989, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_Raise(__pyx_t_8, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __PYX_ERR(1, 989, __pyx_L5_except_error)
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":986
+ * # Cython code.
+ * cdef inline int import_array() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_array()
+ *     except Exception:
+ */
+    __Pyx_PyThreadState_assign
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L10_try_end:;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":985
+ * # Versions of the import_* functions which are more suitable for
+ * # Cython code.
+ * cdef inline int import_array() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_array()
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":991
+ *         raise ImportError("numpy.core.multiarray failed to import")
+ * 
+ * cdef inline int import_umath() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_umath()
+ */
+
+static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  __Pyx_RefNannySetupContext("import_umath", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":992
+ * 
+ * cdef inline int import_umath() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":993
+ * cdef inline int import_umath() except -1:
+ *     try:
+ *         _import_umath()             # <<<<<<<<<<<<<<
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")
+ */
+      __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(1, 993, __pyx_L3_error)
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":992
+ * 
+ * cdef inline int import_umath() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L10_try_end;
+    __pyx_L3_error:;
+    __Pyx_PyThreadState_assign
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":994
+ *     try:
+ *         _import_umath()
+ *     except Exception:             # <<<<<<<<<<<<<<
+ *         raise ImportError("numpy.core.umath failed to import")
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_4) {
+      __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 994, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":995
+ *         _import_umath()
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline int import_ufunc() except -1:
+ */
+      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 995, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_Raise(__pyx_t_8, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __PYX_ERR(1, 995, __pyx_L5_except_error)
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":992
+ * 
+ * cdef inline int import_umath() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+    __Pyx_PyThreadState_assign
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L10_try_end:;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":991
+ *         raise ImportError("numpy.core.multiarray failed to import")
+ * 
+ * cdef inline int import_umath() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_umath()
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":997
+ *         raise ImportError("numpy.core.umath failed to import")
+ * 
+ * cdef inline int import_ufunc() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_umath()
+ */
+
+static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  __Pyx_RefNannySetupContext("import_ufunc", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":998
+ * 
+ * cdef inline int import_ufunc() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":999
+ * cdef inline int import_ufunc() except -1:
+ *     try:
+ *         _import_umath()             # <<<<<<<<<<<<<<
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")
+ */
+      __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(1, 999, __pyx_L3_error)
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":998
+ * 
+ * cdef inline int import_ufunc() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L10_try_end;
+    __pyx_L3_error:;
+    __Pyx_PyThreadState_assign
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":1000
+ *     try:
+ *         _import_umath()
+ *     except Exception:             # <<<<<<<<<<<<<<
+ *         raise ImportError("numpy.core.umath failed to import")
+ */
+    __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_4) {
+      __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1000, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":1001
+ *         _import_umath()
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")             # <<<<<<<<<<<<<<
+ */
+      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__27, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1001, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_Raise(__pyx_t_8, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __PYX_ERR(1, 1001, __pyx_L5_except_error)
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":998
+ * 
+ * cdef inline int import_ufunc() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+    __Pyx_PyThreadState_assign
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L10_try_end:;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":997
+ *         raise ImportError("numpy.core.umath failed to import")
+ * 
+ * cdef inline int import_ufunc() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_umath()
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_tp_new_11pycocotools_5_mask_RLEs(PyTypeObject *t, PyObject *a, PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_11pycocotools_5_mask_4RLEs_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_11pycocotools_5_mask_RLEs(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_11pycocotools_5_mask_4RLEs_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyObject *__pyx_tp_getattro_11pycocotools_5_mask_RLEs(PyObject *o, PyObject *n) {
+  PyObject *v = PyObject_GenericGetAttr(o, n);
+  if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) {
+    PyErr_Clear();
+    v = __pyx_pw_11pycocotools_5_mask_4RLEs_5__getattr__(o, n);
+  }
+  return v;
+}
+
+static PyMethodDef __pyx_methods_11pycocotools_5_mask_RLEs[] = {
+  {"__getattr__", (PyCFunction)__pyx_pw_11pycocotools_5_mask_4RLEs_5__getattr__, METH_O|METH_COEXIST, 0},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_11pycocotools_5_mask_RLEs = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pycocotools._mask.RLEs", /*tp_name*/
+  sizeof(struct __pyx_obj_11pycocotools_5_mask_RLEs), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_11pycocotools_5_mask_RLEs, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  __pyx_tp_getattro_11pycocotools_5_mask_RLEs, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  0, /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_11pycocotools_5_mask_RLEs, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_11pycocotools_5_mask_RLEs, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_11pycocotools_5_mask_Masks(PyTypeObject *t, PyObject *a, PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_11pycocotools_5_mask_5Masks_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_11pycocotools_5_mask_Masks(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_11pycocotools_5_mask_Masks[] = {
+  {"__array__", (PyCFunction)__pyx_pw_11pycocotools_5_mask_5Masks_3__array__, METH_NOARGS, 0},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_11pycocotools_5_mask_Masks = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pycocotools._mask.Masks", /*tp_name*/
+  sizeof(struct __pyx_obj_11pycocotools_5_mask_Masks), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_11pycocotools_5_mask_Masks, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  0, /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_11pycocotools_5_mask_Masks, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_11pycocotools_5_mask_Masks, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyMethodDef __pyx_methods[] = {
+  {0, 0, 0, 0}
+};
+
+#if PY_MAJOR_VERSION >= 3
+static struct PyModuleDef __pyx_moduledef = {
+  #if PY_VERSION_HEX < 0x03020000
+    { PyObject_HEAD_INIT(NULL) NULL, 0, NULL },
+  #else
+    PyModuleDef_HEAD_INIT,
+  #endif
+    "_mask",
+    0, /* m_doc */
+    -1, /* m_size */
+    __pyx_methods /* m_methods */,
+    NULL, /* m_reload */
+    NULL, /* m_traverse */
+    NULL, /* m_clear */
+    NULL /* m_free */
+};
+#endif
+
+static __Pyx_StringTabEntry __pyx_string_tab[] = {
+  {&__pyx_n_s_AttributeError, __pyx_k_AttributeError, sizeof(__pyx_k_AttributeError), 0, 0, 1, 1},
+  {&__pyx_n_s_F, __pyx_k_F, sizeof(__pyx_k_F), 0, 0, 1, 1},
+  {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0},
+  {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0},
+  {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1},
+  {&__pyx_n_s_N, __pyx_k_N, sizeof(__pyx_k_N), 0, 0, 1, 1},
+  {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0},
+  {&__pyx_n_s_PYTHON_VERSION, __pyx_k_PYTHON_VERSION, sizeof(__pyx_k_PYTHON_VERSION), 0, 0, 1, 1},
+  {&__pyx_kp_s_Python_version_must_be_2_or_3, __pyx_k_Python_version_must_be_2_or_3, sizeof(__pyx_k_Python_version_must_be_2_or_3), 0, 0, 1, 0},
+  {&__pyx_n_s_R, __pyx_k_R, sizeof(__pyx_k_R), 0, 0, 1, 1},
+  {&__pyx_n_s_Rs, __pyx_k_Rs, sizeof(__pyx_k_Rs), 0, 0, 1, 1},
+  {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1},
+  {&__pyx_kp_s_The_dt_and_gt_should_have_the_sa, __pyx_k_The_dt_and_gt_should_have_the_sa, sizeof(__pyx_k_The_dt_and_gt_should_have_the_sa), 0, 0, 1, 0},
+  {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1},
+  {&__pyx_n_s_a, __pyx_k_a, sizeof(__pyx_k_a), 0, 0, 1, 1},
+  {&__pyx_n_s_a_2, __pyx_k_a_2, sizeof(__pyx_k_a_2), 0, 0, 1, 1},
+  {&__pyx_n_s_all, __pyx_k_all, sizeof(__pyx_k_all), 0, 0, 1, 1},
+  {&__pyx_n_s_area, __pyx_k_area, sizeof(__pyx_k_area), 0, 0, 1, 1},
+  {&__pyx_n_s_array, __pyx_k_array, sizeof(__pyx_k_array), 0, 0, 1, 1},
+  {&__pyx_n_s_astype, __pyx_k_astype, sizeof(__pyx_k_astype), 0, 0, 1, 1},
+  {&__pyx_n_s_author, __pyx_k_author, sizeof(__pyx_k_author), 0, 0, 1, 1},
+  {&__pyx_n_s_bb, __pyx_k_bb, sizeof(__pyx_k_bb), 0, 0, 1, 1},
+  {&__pyx_n_s_bbIou, __pyx_k_bbIou, sizeof(__pyx_k_bbIou), 0, 0, 1, 1},
+  {&__pyx_n_s_bb_2, __pyx_k_bb_2, sizeof(__pyx_k_bb_2), 0, 0, 1, 1},
+  {&__pyx_n_s_c_string, __pyx_k_c_string, sizeof(__pyx_k_c_string), 0, 0, 1, 1},
+  {&__pyx_n_s_cnts, __pyx_k_cnts, sizeof(__pyx_k_cnts), 0, 0, 1, 1},
+  {&__pyx_n_s_counts, __pyx_k_counts, sizeof(__pyx_k_counts), 0, 0, 1, 1},
+  {&__pyx_n_s_data, __pyx_k_data, sizeof(__pyx_k_data), 0, 0, 1, 1},
+  {&__pyx_n_s_decode, __pyx_k_decode, sizeof(__pyx_k_decode), 0, 0, 1, 1},
+  {&__pyx_n_s_double, __pyx_k_double, sizeof(__pyx_k_double), 0, 0, 1, 1},
+  {&__pyx_n_s_dt, __pyx_k_dt, sizeof(__pyx_k_dt), 0, 0, 1, 1},
+  {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1},
+  {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1},
+  {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1},
+  {&__pyx_n_s_frBbox, __pyx_k_frBbox, sizeof(__pyx_k_frBbox), 0, 0, 1, 1},
+  {&__pyx_n_s_frPoly, __pyx_k_frPoly, sizeof(__pyx_k_frPoly), 0, 0, 1, 1},
+  {&__pyx_n_s_frPyObjects, __pyx_k_frPyObjects, sizeof(__pyx_k_frPyObjects), 0, 0, 1, 1},
+  {&__pyx_n_s_frString, __pyx_k_frString, sizeof(__pyx_k_frString), 0, 0, 1, 1},
+  {&__pyx_n_s_frUncompressedRLE, __pyx_k_frUncompressedRLE, sizeof(__pyx_k_frUncompressedRLE), 0, 0, 1, 1},
+  {&__pyx_n_s_gt, __pyx_k_gt, sizeof(__pyx_k_gt), 0, 0, 1, 1},
+  {&__pyx_n_s_h, __pyx_k_h, sizeof(__pyx_k_h), 0, 0, 1, 1},
+  {&__pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_k_home_yjr_PycharmProjects_Faster, sizeof(__pyx_k_home_yjr_PycharmProjects_Faster), 0, 0, 1, 0},
+  {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1},
+  {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
+  {&__pyx_kp_s_input_data_type_not_allowed, __pyx_k_input_data_type_not_allowed, sizeof(__pyx_k_input_data_type_not_allowed), 0, 0, 1, 0},
+  {&__pyx_kp_s_input_type_is_not_supported, __pyx_k_input_type_is_not_supported, sizeof(__pyx_k_input_type_is_not_supported), 0, 0, 1, 0},
+  {&__pyx_n_s_intersect, __pyx_k_intersect, sizeof(__pyx_k_intersect), 0, 0, 1, 1},
+  {&__pyx_n_s_iou, __pyx_k_iou, sizeof(__pyx_k_iou), 0, 0, 1, 1},
+  {&__pyx_n_s_iouFun, __pyx_k_iouFun, sizeof(__pyx_k_iouFun), 0, 0, 1, 1},
+  {&__pyx_n_s_iou_2, __pyx_k_iou_2, sizeof(__pyx_k_iou_2), 0, 0, 1, 1},
+  {&__pyx_n_s_iou_locals__bbIou, __pyx_k_iou_locals__bbIou, sizeof(__pyx_k_iou_locals__bbIou), 0, 0, 1, 1},
+  {&__pyx_n_s_iou_locals__len, __pyx_k_iou_locals__len, sizeof(__pyx_k_iou_locals__len), 0, 0, 1, 1},
+  {&__pyx_n_s_iou_locals__preproc, __pyx_k_iou_locals__preproc, sizeof(__pyx_k_iou_locals__preproc), 0, 0, 1, 1},
+  {&__pyx_n_s_iou_locals__rleIou, __pyx_k_iou_locals__rleIou, sizeof(__pyx_k_iou_locals__rleIou), 0, 0, 1, 1},
+  {&__pyx_n_s_isbox, __pyx_k_isbox, sizeof(__pyx_k_isbox), 0, 0, 1, 1},
+  {&__pyx_n_s_iscrowd, __pyx_k_iscrowd, sizeof(__pyx_k_iscrowd), 0, 0, 1, 1},
+  {&__pyx_n_s_isrle, __pyx_k_isrle, sizeof(__pyx_k_isrle), 0, 0, 1, 1},
+  {&__pyx_n_s_j, __pyx_k_j, sizeof(__pyx_k_j), 0, 0, 1, 1},
+  {&__pyx_n_s_len, __pyx_k_len, sizeof(__pyx_k_len), 0, 0, 1, 1},
+  {&__pyx_kp_s_list_input_can_be_bounding_box_N, __pyx_k_list_input_can_be_bounding_box_N, sizeof(__pyx_k_list_input_can_be_bounding_box_N), 0, 0, 1, 0},
+  {&__pyx_n_s_m, __pyx_k_m, sizeof(__pyx_k_m), 0, 0, 1, 1},
+  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
+  {&__pyx_n_s_mask, __pyx_k_mask, sizeof(__pyx_k_mask), 0, 0, 1, 1},
+  {&__pyx_n_s_masks, __pyx_k_masks, sizeof(__pyx_k_masks), 0, 0, 1, 1},
+  {&__pyx_n_s_merge, __pyx_k_merge, sizeof(__pyx_k_merge), 0, 0, 1, 1},
+  {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1},
+  {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0},
+  {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0},
+  {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1},
+  {&__pyx_n_s_np_poly, __pyx_k_np_poly, sizeof(__pyx_k_np_poly), 0, 0, 1, 1},
+  {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1},
+  {&__pyx_kp_s_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 0, 1, 0},
+  {&__pyx_kp_s_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 0, 1, 0},
+  {&__pyx_kp_s_numpy_ndarray_input_is_only_for, __pyx_k_numpy_ndarray_input_is_only_for, sizeof(__pyx_k_numpy_ndarray_input_is_only_for), 0, 0, 1, 0},
+  {&__pyx_n_s_obj, __pyx_k_obj, sizeof(__pyx_k_obj), 0, 0, 1, 1},
+  {&__pyx_n_s_objs, __pyx_k_objs, sizeof(__pyx_k_objs), 0, 0, 1, 1},
+  {&__pyx_n_s_order, __pyx_k_order, sizeof(__pyx_k_order), 0, 0, 1, 1},
+  {&__pyx_n_s_p, __pyx_k_p, sizeof(__pyx_k_p), 0, 0, 1, 1},
+  {&__pyx_n_s_poly, __pyx_k_poly, sizeof(__pyx_k_poly), 0, 0, 1, 1},
+  {&__pyx_n_s_preproc, __pyx_k_preproc, sizeof(__pyx_k_preproc), 0, 0, 1, 1},
+  {&__pyx_n_s_py_string, __pyx_k_py_string, sizeof(__pyx_k_py_string), 0, 0, 1, 1},
+  {&__pyx_n_s_pycocotools__mask, __pyx_k_pycocotools__mask, sizeof(__pyx_k_pycocotools__mask), 0, 0, 1, 1},
+  {&__pyx_n_s_pyiscrowd, __pyx_k_pyiscrowd, sizeof(__pyx_k_pyiscrowd), 0, 0, 1, 1},
+  {&__pyx_n_s_pyobj, __pyx_k_pyobj, sizeof(__pyx_k_pyobj), 0, 0, 1, 1},
+  {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1},
+  {&__pyx_n_s_reshape, __pyx_k_reshape, sizeof(__pyx_k_reshape), 0, 0, 1, 1},
+  {&__pyx_n_s_rleIou, __pyx_k_rleIou, sizeof(__pyx_k_rleIou), 0, 0, 1, 1},
+  {&__pyx_n_s_rleObjs, __pyx_k_rleObjs, sizeof(__pyx_k_rleObjs), 0, 0, 1, 1},
+  {&__pyx_n_s_shape, __pyx_k_shape, sizeof(__pyx_k_shape), 0, 0, 1, 1},
+  {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1},
+  {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1},
+  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
+  {&__pyx_n_s_toBbox, __pyx_k_toBbox, sizeof(__pyx_k_toBbox), 0, 0, 1, 1},
+  {&__pyx_n_s_toString, __pyx_k_toString, sizeof(__pyx_k_toString), 0, 0, 1, 1},
+  {&__pyx_n_s_tsungyi, __pyx_k_tsungyi, sizeof(__pyx_k_tsungyi), 0, 0, 1, 1},
+  {&__pyx_n_s_ucRles, __pyx_k_ucRles, sizeof(__pyx_k_ucRles), 0, 0, 1, 1},
+  {&__pyx_n_s_uint32, __pyx_k_uint32, sizeof(__pyx_k_uint32), 0, 0, 1, 1},
+  {&__pyx_n_s_uint8, __pyx_k_uint8, sizeof(__pyx_k_uint8), 0, 0, 1, 1},
+  {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0},
+  {&__pyx_kp_s_unrecognized_type_The_following, __pyx_k_unrecognized_type_The_following, sizeof(__pyx_k_unrecognized_type_The_following), 0, 0, 1, 0},
+  {&__pyx_n_s_utf8, __pyx_k_utf8, sizeof(__pyx_k_utf8), 0, 0, 1, 1},
+  {&__pyx_n_s_version_info, __pyx_k_version_info, sizeof(__pyx_k_version_info), 0, 0, 1, 1},
+  {&__pyx_n_s_w, __pyx_k_w, sizeof(__pyx_k_w), 0, 0, 1, 1},
+  {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1},
+  {0, 0, 0, 0, 0, 0, 0}
+};
+static int __Pyx_InitCachedBuiltins(void) {
+  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 67, __pyx_L1_error)
+  __pyx_builtin_AttributeError = __Pyx_GetBuiltinName(__pyx_n_s_AttributeError); if (!__pyx_builtin_AttributeError) __PYX_ERR(0, 73, __pyx_L1_error)
+  __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 124, __pyx_L1_error)
+  __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 218, __pyx_L1_error)
+  __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 799, __pyx_L1_error)
+  __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 989, __pyx_L1_error)
+  return 0;
+  __pyx_L1_error:;
+  return -1;
+}
+
+static int __Pyx_InitCachedConstants(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
+
+  /* "pycocotools/_mask.pyx":126
+ *     for i, obj in enumerate(rleObjs):
+ *         if PYTHON_VERSION == 2:
+ *             py_string = str(obj['counts']).encode('utf8')             # <<<<<<<<<<<<<<
+ *         elif PYTHON_VERSION == 3:
+ *             py_string = str.encode(obj['counts']) if type(obj['counts']) == str else obj['counts']
+ */
+  __pyx_tuple_ = PyTuple_Pack(1, __pyx_n_s_utf8); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 126, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple_);
+  __Pyx_GIVEREF(__pyx_tuple_);
+
+  /* "pycocotools/_mask.pyx":130
+ *             py_string = str.encode(obj['counts']) if type(obj['counts']) == str else obj['counts']
+ *         else:
+ *             raise Exception('Python version must be 2 or 3')             # <<<<<<<<<<<<<<
+ *         c_string = py_string
+ *         rleFrString( <RLE*> &Rs._R[i], <char*> c_string, obj['size'][0], obj['size'][1] )
+ */
+  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_Python_version_must_be_2_or_3); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__2);
+  __Pyx_GIVEREF(__pyx_tuple__2);
+
+  /* "pycocotools/_mask.pyx":154
+ * def merge(rleObjs, intersect=0):
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     cdef RLEs R = RLEs(1)             # <<<<<<<<<<<<<<
+ *     rleMerge(<RLE*>Rs._R, <RLE*> R._R, <siz> Rs._n, intersect)
+ *     obj = _toString(R)[0]
+ */
+  __pyx_tuple__3 = PyTuple_Pack(1, __pyx_int_1); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 154, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__3);
+  __Pyx_GIVEREF(__pyx_tuple__3);
+
+  /* "pycocotools/_mask.pyx":180
+ *             # check if it's Nx4 bbox
+ *             if not len(objs.shape) == 2 or not objs.shape[1] == 4:
+ *                 raise Exception('numpy ndarray input is only for *bounding boxes* and should have Nx4 dimension')             # <<<<<<<<<<<<<<
+ *             objs = objs.astype(np.double)
+ *         elif type(objs) == list:
+ */
+  __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_numpy_ndarray_input_is_only_for); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 180, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__4);
+  __Pyx_GIVEREF(__pyx_tuple__4);
+
+  /* "pycocotools/_mask.pyx":193
+ *                 objs = _frString(objs)
+ *             else:
+ *                 raise Exception('list input can be bounding box (Nx4) or RLEs ([RLE])')             # <<<<<<<<<<<<<<
+ *         else:
+ *             raise Exception('unrecognized type.  The following type: RLEs (rle), np.ndarray (box), and list (box) are supported.')
+ */
+  __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_list_input_can_be_bounding_box_N); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__5);
+  __Pyx_GIVEREF(__pyx_tuple__5);
+
+  /* "pycocotools/_mask.pyx":195
+ *                 raise Exception('list input can be bounding box (Nx4) or RLEs ([RLE])')
+ *         else:
+ *             raise Exception('unrecognized type.  The following type: RLEs (rle), np.ndarray (box), and list (box) are supported.')             # <<<<<<<<<<<<<<
+ *         return objs
+ *     def _rleIou(RLEs dt, RLEs gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t,  ndim=1] _iou):
+ */
+  __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_unrecognized_type_The_following); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 195, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__6);
+  __Pyx_GIVEREF(__pyx_tuple__6);
+
+  /* "pycocotools/_mask.pyx":172
+ * # iou computation. support function overload (RLEs-RLEs and bbox-bbox).
+ * def iou( dt, gt, pyiscrowd ):
+ *     def _preproc(objs):             # <<<<<<<<<<<<<<
+ *         if len(objs) == 0:
+ *             return objs
+ */
+  __pyx_tuple__7 = PyTuple_Pack(4, __pyx_n_s_objs, __pyx_n_s_isbox, __pyx_n_s_isrle, __pyx_n_s_obj); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 172, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__7);
+  __Pyx_GIVEREF(__pyx_tuple__7);
+  __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(1, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_n_s_preproc, 172, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) __PYX_ERR(0, 172, __pyx_L1_error)
+
+  /* "pycocotools/_mask.pyx":197
+ *             raise Exception('unrecognized type.  The following type: RLEs (rle), np.ndarray (box), and list (box) are supported.')
+ *         return objs
+ *     def _rleIou(RLEs dt, RLEs gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t,  ndim=1] _iou):             # <<<<<<<<<<<<<<
+ *         rleIou( <RLE*> dt._R, <RLE*> gt._R, m, n, <byte*> iscrowd.data, <double*> _iou.data )
+ *     def _bbIou(np.ndarray[np.double_t, ndim=2] dt, np.ndarray[np.double_t, ndim=2] gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t, ndim=1] _iou):
+ */
+  __pyx_tuple__9 = PyTuple_Pack(6, __pyx_n_s_dt, __pyx_n_s_gt, __pyx_n_s_iscrowd, __pyx_n_s_m, __pyx_n_s_n, __pyx_n_s_iou); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__9);
+  __Pyx_GIVEREF(__pyx_tuple__9);
+  __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(6, 0, 6, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_n_s_rleIou, 197, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) __PYX_ERR(0, 197, __pyx_L1_error)
+
+  /* "pycocotools/_mask.pyx":199
+ *     def _rleIou(RLEs dt, RLEs gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t,  ndim=1] _iou):
+ *         rleIou( <RLE*> dt._R, <RLE*> gt._R, m, n, <byte*> iscrowd.data, <double*> _iou.data )
+ *     def _bbIou(np.ndarray[np.double_t, ndim=2] dt, np.ndarray[np.double_t, ndim=2] gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t, ndim=1] _iou):             # <<<<<<<<<<<<<<
+ *         bbIou( <BB> dt.data, <BB> gt.data, m, n, <byte*> iscrowd.data, <double*>_iou.data )
+ *     def _len(obj):
+ */
+  __pyx_tuple__11 = PyTuple_Pack(6, __pyx_n_s_dt, __pyx_n_s_gt, __pyx_n_s_iscrowd, __pyx_n_s_m, __pyx_n_s_n, __pyx_n_s_iou); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__11);
+  __Pyx_GIVEREF(__pyx_tuple__11);
+  __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(6, 0, 6, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_n_s_bbIou, 199, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(0, 199, __pyx_L1_error)
+
+  /* "pycocotools/_mask.pyx":201
+ *     def _bbIou(np.ndarray[np.double_t, ndim=2] dt, np.ndarray[np.double_t, ndim=2] gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t, ndim=1] _iou):
+ *         bbIou( <BB> dt.data, <BB> gt.data, m, n, <byte*> iscrowd.data, <double*>_iou.data )
+ *     def _len(obj):             # <<<<<<<<<<<<<<
+ *         cdef siz N = 0
+ *         if type(obj) == RLEs:
+ */
+  __pyx_tuple__13 = PyTuple_Pack(2, __pyx_n_s_obj, __pyx_n_s_N); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 201, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__13);
+  __Pyx_GIVEREF(__pyx_tuple__13);
+  __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_n_s_len, 201, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 201, __pyx_L1_error)
+
+  /* "pycocotools/_mask.pyx":221
+ *         return []
+ *     if not type(dt) == type(gt):
+ *         raise Exception('The dt and gt should have the same data type, either RLEs, list or np.ndarray')             # <<<<<<<<<<<<<<
+ * 
+ *     # define local variables
+ */
+  __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_s_The_dt_and_gt_should_have_the_sa); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 221, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__15);
+  __Pyx_GIVEREF(__pyx_tuple__15);
+
+  /* "pycocotools/_mask.pyx":232
+ *         _iouFun = _bbIou
+ *     else:
+ *         raise Exception('input data type not allowed.')             # <<<<<<<<<<<<<<
+ *     _iou = <double*> malloc(m*n* sizeof(double))
+ *     iou = np.zeros((m*n, ), dtype=np.double)
+ */
+  __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_s_input_data_type_not_allowed); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 232, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__16);
+  __Pyx_GIVEREF(__pyx_tuple__16);
+
+  /* "pycocotools/_mask.pyx":277
+ *     objs = []
+ *     for i in range(n):
+ *         Rs = RLEs(1)             # <<<<<<<<<<<<<<
+ *         cnts = np.array(ucRles[i]['counts'], dtype=np.uint32)
+ *         # time for malloc can be saved here but it's fine
+ */
+  __pyx_tuple__17 = PyTuple_Pack(1, __pyx_int_1); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 277, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__17);
+  __Pyx_GIVEREF(__pyx_tuple__17);
+
+  /* "pycocotools/_mask.pyx":307
+ *         objs = frUncompressedRLE([pyobj], h, w)[0]
+ *     else:
+ *         raise Exception('input type is not supported.')             # <<<<<<<<<<<<<<
+ *     return objs
+ */
+  __pyx_tuple__18 = PyTuple_Pack(1, __pyx_kp_s_input_type_is_not_supported); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 307, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__18);
+  __Pyx_GIVEREF(__pyx_tuple__18);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":218
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")             # <<<<<<<<<<<<<<
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ */
+  __pyx_tuple__19 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(1, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__19);
+  __Pyx_GIVEREF(__pyx_tuple__19);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":222
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")             # <<<<<<<<<<<<<<
+ * 
+ *             info.buf = PyArray_DATA(self)
+ */
+  __pyx_tuple__20 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(1, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__20);
+  __Pyx_GIVEREF(__pyx_tuple__20);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":259
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
+ *                 if   t == NPY_BYTE:        f = "b"
+ *                 elif t == NPY_UBYTE:       f = "B"
+ */
+  __pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(1, 259, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__21);
+  __Pyx_GIVEREF(__pyx_tuple__21);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":799
+ * 
+ *         if (end - f) - <int>(new_offset - offset[0]) < 15:
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")             # <<<<<<<<<<<<<<
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or
+ */
+  __pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(1, 799, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__22);
+  __Pyx_GIVEREF(__pyx_tuple__22);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":803
+ *         if ((child.byteorder == c'>' and little_endian) or
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
+ *             # One could encode it in the format string and have Cython
+ *             # complain instead, BUT: < and > in format strings also imply
+ */
+  __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(1, 803, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__23);
+  __Pyx_GIVEREF(__pyx_tuple__23);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":823
+ *             t = child.type_num
+ *             if end - f < 5:
+ *                 raise RuntimeError(u"Format string allocated too short.")             # <<<<<<<<<<<<<<
+ * 
+ *             # Until ticket #99 is fixed, use integers to avoid warnings
+ */
+  __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(1, 823, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__24);
+  __Pyx_GIVEREF(__pyx_tuple__24);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":989
+ *         _import_array()
+ *     except Exception:
+ *         raise ImportError("numpy.core.multiarray failed to import")             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline int import_umath() except -1:
+ */
+  __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(1, 989, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__25);
+  __Pyx_GIVEREF(__pyx_tuple__25);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":995
+ *         _import_umath()
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline int import_ufunc() except -1:
+ */
+  __pyx_tuple__26 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(1, 995, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__26);
+  __Pyx_GIVEREF(__pyx_tuple__26);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":1001
+ *         _import_umath()
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")             # <<<<<<<<<<<<<<
+ */
+  __pyx_tuple__27 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(1, 1001, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__27);
+  __Pyx_GIVEREF(__pyx_tuple__27);
+
+  /* "pycocotools/_mask.pyx":103
+ * 
+ * # internal conversion from Python RLEs object to compressed RLE format
+ * def _toString(RLEs Rs):             # <<<<<<<<<<<<<<
+ *     cdef siz n = Rs.n
+ *     cdef bytes py_string
+ */
+  __pyx_tuple__28 = PyTuple_Pack(6, __pyx_n_s_Rs, __pyx_n_s_n, __pyx_n_s_py_string, __pyx_n_s_c_string, __pyx_n_s_objs, __pyx_n_s_i); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 103, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__28);
+  __Pyx_GIVEREF(__pyx_tuple__28);
+  __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(1, 0, 6, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__28, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_n_s_toString, 103, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(0, 103, __pyx_L1_error)
+
+  /* "pycocotools/_mask.pyx":119
+ * 
+ * # internal conversion from compressed RLE format to Python RLEs object
+ * def _frString(rleObjs):             # <<<<<<<<<<<<<<
+ *     cdef siz n = len(rleObjs)
+ *     Rs = RLEs(n)
+ */
+  __pyx_tuple__30 = PyTuple_Pack(7, __pyx_n_s_rleObjs, __pyx_n_s_n, __pyx_n_s_Rs, __pyx_n_s_py_string, __pyx_n_s_c_string, __pyx_n_s_i, __pyx_n_s_obj); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 119, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__30);
+  __Pyx_GIVEREF(__pyx_tuple__30);
+  __pyx_codeobj__31 = (PyObject*)__Pyx_PyCode_New(1, 0, 7, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__30, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_n_s_frString, 119, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__31)) __PYX_ERR(0, 119, __pyx_L1_error)
+
+  /* "pycocotools/_mask.pyx":137
+ * # encode mask to RLEs objects
+ * # list of RLE string can be generated by RLEs member function
+ * def encode(np.ndarray[np.uint8_t, ndim=3, mode='fortran'] mask):             # <<<<<<<<<<<<<<
+ *     h, w, n = mask.shape[0], mask.shape[1], mask.shape[2]
+ *     cdef RLEs Rs = RLEs(n)
+ */
+  __pyx_tuple__32 = PyTuple_Pack(6, __pyx_n_s_mask, __pyx_n_s_h, __pyx_n_s_w, __pyx_n_s_n, __pyx_n_s_Rs, __pyx_n_s_objs); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 137, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__32);
+  __Pyx_GIVEREF(__pyx_tuple__32);
+  __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(1, 0, 6, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__32, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_n_s_encode, 137, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(0, 137, __pyx_L1_error)
+
+  /* "pycocotools/_mask.pyx":145
+ * 
+ * # decode mask from compressed list of RLE string or RLEs object
+ * def decode(rleObjs):             # <<<<<<<<<<<<<<
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     h, w, n = Rs._R[0].h, Rs._R[0].w, Rs._n
+ */
+  __pyx_tuple__34 = PyTuple_Pack(6, __pyx_n_s_rleObjs, __pyx_n_s_Rs, __pyx_n_s_h, __pyx_n_s_w, __pyx_n_s_n, __pyx_n_s_masks); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 145, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__34);
+  __Pyx_GIVEREF(__pyx_tuple__34);
+  __pyx_codeobj__35 = (PyObject*)__Pyx_PyCode_New(1, 0, 6, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__34, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_n_s_decode, 145, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__35)) __PYX_ERR(0, 145, __pyx_L1_error)
+
+  /* "pycocotools/_mask.pyx":152
+ *     return np.array(masks)
+ * 
+ * def merge(rleObjs, intersect=0):             # <<<<<<<<<<<<<<
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     cdef RLEs R = RLEs(1)
+ */
+  __pyx_tuple__36 = PyTuple_Pack(5, __pyx_n_s_rleObjs, __pyx_n_s_intersect, __pyx_n_s_Rs, __pyx_n_s_R, __pyx_n_s_obj); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(0, 152, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__36);
+  __Pyx_GIVEREF(__pyx_tuple__36);
+  __pyx_codeobj__37 = (PyObject*)__Pyx_PyCode_New(2, 0, 5, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__36, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_n_s_merge, 152, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__37)) __PYX_ERR(0, 152, __pyx_L1_error)
+
+  /* "pycocotools/_mask.pyx":159
+ *     return obj
+ * 
+ * def area(rleObjs):             # <<<<<<<<<<<<<<
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     cdef uint* _a = <uint*> malloc(Rs._n* sizeof(uint))
+ */
+  __pyx_tuple__38 = PyTuple_Pack(5, __pyx_n_s_rleObjs, __pyx_n_s_Rs, __pyx_n_s_a, __pyx_n_s_shape, __pyx_n_s_a_2); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(0, 159, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__38);
+  __Pyx_GIVEREF(__pyx_tuple__38);
+  __pyx_codeobj__39 = (PyObject*)__Pyx_PyCode_New(1, 0, 5, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__38, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_n_s_area, 159, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__39)) __PYX_ERR(0, 159, __pyx_L1_error)
+
+  /* "pycocotools/_mask.pyx":171
+ * 
+ * # iou computation. support function overload (RLEs-RLEs and bbox-bbox).
+ * def iou( dt, gt, pyiscrowd ):             # <<<<<<<<<<<<<<
+ *     def _preproc(objs):
+ *         if len(objs) == 0:
+ */
+  __pyx_tuple__40 = PyTuple_Pack(18, __pyx_n_s_dt, __pyx_n_s_gt, __pyx_n_s_pyiscrowd, __pyx_n_s_preproc, __pyx_n_s_preproc, __pyx_n_s_rleIou, __pyx_n_s_rleIou, __pyx_n_s_bbIou, __pyx_n_s_bbIou, __pyx_n_s_len, __pyx_n_s_len, __pyx_n_s_iscrowd, __pyx_n_s_m, __pyx_n_s_n, __pyx_n_s_iou, __pyx_n_s_shape, __pyx_n_s_iouFun, __pyx_n_s_iou_2); if (unlikely(!__pyx_tuple__40)) __PYX_ERR(0, 171, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__40);
+  __Pyx_GIVEREF(__pyx_tuple__40);
+  __pyx_codeobj__41 = (PyObject*)__Pyx_PyCode_New(3, 0, 18, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__40, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_n_s_iou_2, 171, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__41)) __PYX_ERR(0, 171, __pyx_L1_error)
+
+  /* "pycocotools/_mask.pyx":241
+ *     return iou.reshape((m,n), order='F')
+ * 
+ * def toBbox( rleObjs ):             # <<<<<<<<<<<<<<
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     cdef siz n = Rs.n
+ */
+  __pyx_tuple__42 = PyTuple_Pack(6, __pyx_n_s_rleObjs, __pyx_n_s_Rs, __pyx_n_s_n, __pyx_n_s_bb_2, __pyx_n_s_shape, __pyx_n_s_bb); if (unlikely(!__pyx_tuple__42)) __PYX_ERR(0, 241, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__42);
+  __Pyx_GIVEREF(__pyx_tuple__42);
+  __pyx_codeobj__43 = (PyObject*)__Pyx_PyCode_New(1, 0, 6, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__42, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_n_s_toBbox, 241, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__43)) __PYX_ERR(0, 241, __pyx_L1_error)
+
+  /* "pycocotools/_mask.pyx":253
+ *     return bb
+ * 
+ * def frBbox(np.ndarray[np.double_t, ndim=2] bb, siz h, siz w ):             # <<<<<<<<<<<<<<
+ *     cdef siz n = bb.shape[0]
+ *     Rs = RLEs(n)
+ */
+  __pyx_tuple__44 = PyTuple_Pack(6, __pyx_n_s_bb, __pyx_n_s_h, __pyx_n_s_w, __pyx_n_s_n, __pyx_n_s_Rs, __pyx_n_s_objs); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(0, 253, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__44);
+  __Pyx_GIVEREF(__pyx_tuple__44);
+  __pyx_codeobj__45 = (PyObject*)__Pyx_PyCode_New(3, 0, 6, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_n_s_frBbox, 253, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__45)) __PYX_ERR(0, 253, __pyx_L1_error)
+
+  /* "pycocotools/_mask.pyx":260
+ *     return objs
+ * 
+ * def frPoly( poly, siz h, siz w ):             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.double_t, ndim=1] np_poly
+ *     n = len(poly)
+ */
+  __pyx_tuple__46 = PyTuple_Pack(9, __pyx_n_s_poly, __pyx_n_s_h, __pyx_n_s_w, __pyx_n_s_np_poly, __pyx_n_s_n, __pyx_n_s_Rs, __pyx_n_s_i, __pyx_n_s_p, __pyx_n_s_objs); if (unlikely(!__pyx_tuple__46)) __PYX_ERR(0, 260, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__46);
+  __Pyx_GIVEREF(__pyx_tuple__46);
+  __pyx_codeobj__47 = (PyObject*)__Pyx_PyCode_New(3, 0, 9, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__46, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_n_s_frPoly, 260, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__47)) __PYX_ERR(0, 260, __pyx_L1_error)
+
+  /* "pycocotools/_mask.pyx":270
+ *     return objs
+ * 
+ * def frUncompressedRLE(ucRles, siz h, siz w):             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.uint32_t, ndim=1] cnts
+ *     cdef RLE R
+ */
+  __pyx_tuple__48 = PyTuple_Pack(11, __pyx_n_s_ucRles, __pyx_n_s_h, __pyx_n_s_w, __pyx_n_s_cnts, __pyx_n_s_R, __pyx_n_s_data, __pyx_n_s_n, __pyx_n_s_objs, __pyx_n_s_i, __pyx_n_s_Rs, __pyx_n_s_j); if (unlikely(!__pyx_tuple__48)) __PYX_ERR(0, 270, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__48);
+  __Pyx_GIVEREF(__pyx_tuple__48);
+  __pyx_codeobj__49 = (PyObject*)__Pyx_PyCode_New(3, 0, 11, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__48, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_n_s_frUncompressedRLE, 270, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__49)) __PYX_ERR(0, 270, __pyx_L1_error)
+
+  /* "pycocotools/_mask.pyx":288
+ *     return objs
+ * 
+ * def frPyObjects(pyobj, h, w):             # <<<<<<<<<<<<<<
+ *     # encode rle from a list of python objects
+ *     if type(pyobj) == np.ndarray:
+ */
+  __pyx_tuple__50 = PyTuple_Pack(4, __pyx_n_s_pyobj, __pyx_n_s_h, __pyx_n_s_w, __pyx_n_s_objs); if (unlikely(!__pyx_tuple__50)) __PYX_ERR(0, 288, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__50);
+  __Pyx_GIVEREF(__pyx_tuple__50);
+  __pyx_codeobj__51 = (PyObject*)__Pyx_PyCode_New(3, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__50, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_n_s_frPyObjects, 288, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__51)) __PYX_ERR(0, 288, __pyx_L1_error)
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+
+static int __Pyx_InitGlobals(void) {
+  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+  __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_4 = PyInt_FromLong(4); if (unlikely(!__pyx_int_4)) __PYX_ERR(0, 1, __pyx_L1_error)
+  return 0;
+  __pyx_L1_error:;
+  return -1;
+}
+
+#if PY_MAJOR_VERSION < 3
+PyMODINIT_FUNC init_mask(void); /*proto*/
+PyMODINIT_FUNC init_mask(void)
+#else
+PyMODINIT_FUNC PyInit__mask(void); /*proto*/
+PyMODINIT_FUNC PyInit__mask(void)
+#endif
+{
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_3;
+  __Pyx_RefNannyDeclarations
+  #if CYTHON_REFNANNY
+  __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
+  if (!__Pyx_RefNanny) {
+      PyErr_Clear();
+      __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny");
+      if (!__Pyx_RefNanny)
+          Py_FatalError("failed to import 'refnanny' module");
+  }
+  #endif
+  __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit__mask(void)", 0);
+  if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #ifdef __Pyx_CyFunction_USED
+  if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_Generator_USED
+  if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_StopAsyncIteration_USED
+  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  /*--- Library function declarations ---*/
+  /*--- Threads initialization code ---*/
+  #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
+  #ifdef WITH_THREAD /* Python build with threading support? */
+  PyEval_InitThreads();
+  #endif
+  #endif
+  /*--- Module creation code ---*/
+  #if PY_MAJOR_VERSION < 3
+  __pyx_m = Py_InitModule4("_mask", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
+  #else
+  __pyx_m = PyModule_Create(&__pyx_moduledef);
+  #endif
+  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
+  Py_INCREF(__pyx_d);
+  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #if CYTHON_COMPILING_IN_PYPY
+  Py_INCREF(__pyx_b);
+  #endif
+  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+  /*--- Initialize various global constants etc. ---*/
+  if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
+  if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  if (__pyx_module_is_main_pycocotools___mask) {
+    if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  }
+  #if PY_MAJOR_VERSION >= 3
+  {
+    PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
+    if (!PyDict_GetItemString(modules, "pycocotools._mask")) {
+      if (unlikely(PyDict_SetItemString(modules, "pycocotools._mask", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+    }
+  }
+  #endif
+  /*--- Builtin init code ---*/
+  if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  /*--- Constants init code ---*/
+  if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  /*--- Global init code ---*/
+  /*--- Variable export code ---*/
+  /*--- Function export code ---*/
+  /*--- Type init code ---*/
+  if (PyType_Ready(&__pyx_type_11pycocotools_5_mask_RLEs) < 0) __PYX_ERR(0, 56, __pyx_L1_error)
+  __pyx_type_11pycocotools_5_mask_RLEs.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "RLEs", (PyObject *)&__pyx_type_11pycocotools_5_mask_RLEs) < 0) __PYX_ERR(0, 56, __pyx_L1_error)
+  __pyx_ptype_11pycocotools_5_mask_RLEs = &__pyx_type_11pycocotools_5_mask_RLEs;
+  if (PyType_Ready(&__pyx_type_11pycocotools_5_mask_Masks) < 0) __PYX_ERR(0, 77, __pyx_L1_error)
+  __pyx_type_11pycocotools_5_mask_Masks.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "Masks", (PyObject *)&__pyx_type_11pycocotools_5_mask_Masks) < 0) __PYX_ERR(0, 77, __pyx_L1_error)
+  __pyx_ptype_11pycocotools_5_mask_Masks = &__pyx_type_11pycocotools_5_mask_Masks;
+  /*--- Type import code ---*/
+  __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "type", 
+  #if CYTHON_COMPILING_IN_PYPY
+  sizeof(PyTypeObject),
+  #else
+  sizeof(PyHeapTypeObject),
+  #endif
+  0); if (unlikely(!__pyx_ptype_7cpython_4type_type)) __PYX_ERR(2, 9, __pyx_L1_error)
+  __pyx_ptype_5numpy_dtype = __Pyx_ImportType("numpy", "dtype", sizeof(PyArray_Descr), 0); if (unlikely(!__pyx_ptype_5numpy_dtype)) __PYX_ERR(1, 155, __pyx_L1_error)
+  __pyx_ptype_5numpy_flatiter = __Pyx_ImportType("numpy", "flatiter", sizeof(PyArrayIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_flatiter)) __PYX_ERR(1, 168, __pyx_L1_error)
+  __pyx_ptype_5numpy_broadcast = __Pyx_ImportType("numpy", "broadcast", sizeof(PyArrayMultiIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_broadcast)) __PYX_ERR(1, 172, __pyx_L1_error)
+  __pyx_ptype_5numpy_ndarray = __Pyx_ImportType("numpy", "ndarray", sizeof(PyArrayObject), 0); if (unlikely(!__pyx_ptype_5numpy_ndarray)) __PYX_ERR(1, 181, __pyx_L1_error)
+  __pyx_ptype_5numpy_ufunc = __Pyx_ImportType("numpy", "ufunc", sizeof(PyUFuncObject), 0); if (unlikely(!__pyx_ptype_5numpy_ufunc)) __PYX_ERR(1, 861, __pyx_L1_error)
+  /*--- Variable import code ---*/
+  /*--- Function import code ---*/
+  /*--- Execution code ---*/
+  #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
+  if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+
+  /* "pycocotools/_mask.pyx":11
+ * #**************************************************************************
+ * 
+ * __author__ = 'tsungyi'             # <<<<<<<<<<<<<<
+ * 
+ * import sys
+ */
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_author, __pyx_n_s_tsungyi) < 0) __PYX_ERR(0, 11, __pyx_L1_error)
+
+  /* "pycocotools/_mask.pyx":13
+ * __author__ = 'tsungyi'
+ * 
+ * import sys             # <<<<<<<<<<<<<<
+ * PYTHON_VERSION = sys.version_info[0]
+ * 
+ */
+  __pyx_t_1 = __Pyx_Import(__pyx_n_s_sys, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_1) < 0) __PYX_ERR(0, 13, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":14
+ * 
+ * import sys
+ * PYTHON_VERSION = sys.version_info[0]             # <<<<<<<<<<<<<<
+ * 
+ * # import both Python-level and C-level symbols of Numpy
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_version_info); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 14, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PYTHON_VERSION, __pyx_t_1) < 0) __PYX_ERR(0, 14, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":18
+ * # import both Python-level and C-level symbols of Numpy
+ * # the API uses Numpy to interface C and Python
+ * import numpy as np             # <<<<<<<<<<<<<<
+ * cimport numpy as np
+ * from libc.stdlib cimport malloc, free
+ */
+  __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 18, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":23
+ * 
+ * # intialized Numpy. must do.
+ * np.import_array()             # <<<<<<<<<<<<<<
+ * 
+ * # import numpy C function
+ */
+  __pyx_t_3 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(0, 23, __pyx_L1_error)
+
+  /* "pycocotools/_mask.pyx":103
+ * 
+ * # internal conversion from Python RLEs object to compressed RLE format
+ * def _toString(RLEs Rs):             # <<<<<<<<<<<<<<
+ *     cdef siz n = Rs.n
+ *     cdef bytes py_string
+ */
+  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_11pycocotools_5_mask_1_toString, NULL, __pyx_n_s_pycocotools__mask); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 103, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_toString, __pyx_t_1) < 0) __PYX_ERR(0, 103, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":119
+ * 
+ * # internal conversion from compressed RLE format to Python RLEs object
+ * def _frString(rleObjs):             # <<<<<<<<<<<<<<
+ *     cdef siz n = len(rleObjs)
+ *     Rs = RLEs(n)
+ */
+  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_11pycocotools_5_mask_3_frString, NULL, __pyx_n_s_pycocotools__mask); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 119, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_frString, __pyx_t_1) < 0) __PYX_ERR(0, 119, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":137
+ * # encode mask to RLEs objects
+ * # list of RLE string can be generated by RLEs member function
+ * def encode(np.ndarray[np.uint8_t, ndim=3, mode='fortran'] mask):             # <<<<<<<<<<<<<<
+ *     h, w, n = mask.shape[0], mask.shape[1], mask.shape[2]
+ *     cdef RLEs Rs = RLEs(n)
+ */
+  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_11pycocotools_5_mask_5encode, NULL, __pyx_n_s_pycocotools__mask); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 137, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_encode, __pyx_t_1) < 0) __PYX_ERR(0, 137, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":145
+ * 
+ * # decode mask from compressed list of RLE string or RLEs object
+ * def decode(rleObjs):             # <<<<<<<<<<<<<<
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     h, w, n = Rs._R[0].h, Rs._R[0].w, Rs._n
+ */
+  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_11pycocotools_5_mask_7decode, NULL, __pyx_n_s_pycocotools__mask); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 145, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_decode, __pyx_t_1) < 0) __PYX_ERR(0, 145, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":152
+ *     return np.array(masks)
+ * 
+ * def merge(rleObjs, intersect=0):             # <<<<<<<<<<<<<<
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     cdef RLEs R = RLEs(1)
+ */
+  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_11pycocotools_5_mask_9merge, NULL, __pyx_n_s_pycocotools__mask); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 152, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_merge, __pyx_t_1) < 0) __PYX_ERR(0, 152, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":159
+ *     return obj
+ * 
+ * def area(rleObjs):             # <<<<<<<<<<<<<<
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     cdef uint* _a = <uint*> malloc(Rs._n* sizeof(uint))
+ */
+  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_11pycocotools_5_mask_11area, NULL, __pyx_n_s_pycocotools__mask); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 159, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_area, __pyx_t_1) < 0) __PYX_ERR(0, 159, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":171
+ * 
+ * # iou computation. support function overload (RLEs-RLEs and bbox-bbox).
+ * def iou( dt, gt, pyiscrowd ):             # <<<<<<<<<<<<<<
+ *     def _preproc(objs):
+ *         if len(objs) == 0:
+ */
+  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_11pycocotools_5_mask_13iou, NULL, __pyx_n_s_pycocotools__mask); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 171, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_iou_2, __pyx_t_1) < 0) __PYX_ERR(0, 171, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":241
+ *     return iou.reshape((m,n), order='F')
+ * 
+ * def toBbox( rleObjs ):             # <<<<<<<<<<<<<<
+ *     cdef RLEs Rs = _frString(rleObjs)
+ *     cdef siz n = Rs.n
+ */
+  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_11pycocotools_5_mask_15toBbox, NULL, __pyx_n_s_pycocotools__mask); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 241, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_toBbox, __pyx_t_1) < 0) __PYX_ERR(0, 241, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":253
+ *     return bb
+ * 
+ * def frBbox(np.ndarray[np.double_t, ndim=2] bb, siz h, siz w ):             # <<<<<<<<<<<<<<
+ *     cdef siz n = bb.shape[0]
+ *     Rs = RLEs(n)
+ */
+  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_11pycocotools_5_mask_17frBbox, NULL, __pyx_n_s_pycocotools__mask); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 253, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_frBbox, __pyx_t_1) < 0) __PYX_ERR(0, 253, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":260
+ *     return objs
+ * 
+ * def frPoly( poly, siz h, siz w ):             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.double_t, ndim=1] np_poly
+ *     n = len(poly)
+ */
+  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_11pycocotools_5_mask_19frPoly, NULL, __pyx_n_s_pycocotools__mask); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 260, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_frPoly, __pyx_t_1) < 0) __PYX_ERR(0, 260, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":270
+ *     return objs
+ * 
+ * def frUncompressedRLE(ucRles, siz h, siz w):             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.uint32_t, ndim=1] cnts
+ *     cdef RLE R
+ */
+  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_11pycocotools_5_mask_21frUncompressedRLE, NULL, __pyx_n_s_pycocotools__mask); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 270, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_frUncompressedRLE, __pyx_t_1) < 0) __PYX_ERR(0, 270, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":288
+ *     return objs
+ * 
+ * def frPyObjects(pyobj, h, w):             # <<<<<<<<<<<<<<
+ *     # encode rle from a list of python objects
+ *     if type(pyobj) == np.ndarray:
+ */
+  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_11pycocotools_5_mask_23frPyObjects, NULL, __pyx_n_s_pycocotools__mask); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 288, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_frPyObjects, __pyx_t_1) < 0) __PYX_ERR(0, 288, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pycocotools/_mask.pyx":1
+ * # distutils: language = c             # <<<<<<<<<<<<<<
+ * # distutils: sources = ../common/maskApi.c
+ * 
+ */
+  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":997
+ *         raise ImportError("numpy.core.umath failed to import")
+ * 
+ * cdef inline int import_ufunc() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_umath()
+ */
+
+  /*--- Wrapped vars code ---*/
+
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  if (__pyx_m) {
+    if (__pyx_d) {
+      __Pyx_AddTraceback("init pycocotools._mask", __pyx_clineno, __pyx_lineno, __pyx_filename);
+    }
+    Py_DECREF(__pyx_m); __pyx_m = 0;
+  } else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_ImportError, "init pycocotools._mask");
+  }
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  #if PY_MAJOR_VERSION < 3
+  return;
+  #else
+  return __pyx_m;
+  #endif
+}
+
+/* --- Runtime support code --- */
+/* Refnanny */
+#if CYTHON_REFNANNY
+static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
+    PyObject *m = NULL, *p = NULL;
+    void *r = NULL;
+    m = PyImport_ImportModule((char *)modname);
+    if (!m) goto end;
+    p = PyObject_GetAttrString(m, (char *)"RefNannyAPI");
+    if (!p) goto end;
+    r = PyLong_AsVoidPtr(p);
+end:
+    Py_XDECREF(p);
+    Py_XDECREF(m);
+    return (__Pyx_RefNannyAPIStruct *)r;
+}
+#endif
+
+/* GetBuiltinName */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
+    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
+    if (unlikely(!result)) {
+        PyErr_Format(PyExc_NameError,
+#if PY_MAJOR_VERSION >= 3
+            "name '%U' is not defined", name);
+#else
+            "name '%.200s' is not defined", PyString_AS_STRING(name));
+#endif
+    }
+    return result;
+}
+
+/* RaiseDoubleKeywords */
+static void __Pyx_RaiseDoubleKeywordsError(
+    const char* func_name,
+    PyObject* kw_name)
+{
+    PyErr_Format(PyExc_TypeError,
+        #if PY_MAJOR_VERSION >= 3
+        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
+        #else
+        "%s() got multiple values for keyword argument '%s'", func_name,
+        PyString_AsString(kw_name));
+        #endif
+}
+
+/* ParseKeywords */
+static int __Pyx_ParseOptionalKeywords(
+    PyObject *kwds,
+    PyObject **argnames[],
+    PyObject *kwds2,
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    const char* function_name)
+{
+    PyObject *key = 0, *value = 0;
+    Py_ssize_t pos = 0;
+    PyObject*** name;
+    PyObject*** first_kw_arg = argnames + num_pos_args;
+    while (PyDict_Next(kwds, &pos, &key, &value)) {
+        name = first_kw_arg;
+        while (*name && (**name != key)) name++;
+        if (*name) {
+            values[name-argnames] = value;
+            continue;
+        }
+        name = first_kw_arg;
+        #if PY_MAJOR_VERSION < 3
+        if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) {
+            while (*name) {
+                if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
+                        && _PyString_Eq(**name, key)) {
+                    values[name-argnames] = value;
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    if ((**argname == key) || (
+                            (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))
+                             && _PyString_Eq(**argname, key))) {
+                        goto arg_passed_twice;
+                    }
+                    argname++;
+                }
+            }
+        } else
+        #endif
+        if (likely(PyUnicode_Check(key))) {
+            while (*name) {
+                int cmp = (**name == key) ? 0 :
+                #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+                    (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 :
+                #endif
+                    PyUnicode_Compare(**name, key);
+                if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                if (cmp == 0) {
+                    values[name-argnames] = value;
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    int cmp = (**argname == key) ? 0 :
+                    #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+                        (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 :
+                    #endif
+                        PyUnicode_Compare(**argname, key);
+                    if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                    if (cmp == 0) goto arg_passed_twice;
+                    argname++;
+                }
+            }
+        } else
+            goto invalid_keyword_type;
+        if (kwds2) {
+            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
+        } else {
+            goto invalid_keyword;
+        }
+    }
+    return 0;
+arg_passed_twice:
+    __Pyx_RaiseDoubleKeywordsError(function_name, key);
+    goto bad;
+invalid_keyword_type:
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() keywords must be strings", function_name);
+    goto bad;
+invalid_keyword:
+    PyErr_Format(PyExc_TypeError,
+    #if PY_MAJOR_VERSION < 3
+        "%.200s() got an unexpected keyword argument '%.200s'",
+        function_name, PyString_AsString(key));
+    #else
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    #endif
+bad:
+    return -1;
+}
+
+/* RaiseArgTupleInvalid */
+static void __Pyx_RaiseArgtupleInvalid(
+    const char* func_name,
+    int exact,
+    Py_ssize_t num_min,
+    Py_ssize_t num_max,
+    Py_ssize_t num_found)
+{
+    Py_ssize_t num_expected;
+    const char *more_or_less;
+    if (num_found < num_min) {
+        num_expected = num_min;
+        more_or_less = "at least";
+    } else {
+        num_expected = num_max;
+        more_or_less = "at most";
+    }
+    if (exact) {
+        more_or_less = "exactly";
+    }
+    PyErr_Format(PyExc_TypeError,
+                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                 func_name, more_or_less, num_expected,
+                 (num_expected == 1) ? "" : "s", num_found);
+}
+
+/* BytesEquals */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+    if (s1 == s2) {
+        return (equals == Py_EQ);
+    } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) {
+        const char *ps1, *ps2;
+        Py_ssize_t length = PyBytes_GET_SIZE(s1);
+        if (length != PyBytes_GET_SIZE(s2))
+            return (equals == Py_NE);
+        ps1 = PyBytes_AS_STRING(s1);
+        ps2 = PyBytes_AS_STRING(s2);
+        if (ps1[0] != ps2[0]) {
+            return (equals == Py_NE);
+        } else if (length == 1) {
+            return (equals == Py_EQ);
+        } else {
+            int result = memcmp(ps1, ps2, (size_t)length);
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) {
+        return (equals == Py_NE);
+    } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) {
+        return (equals == Py_NE);
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+#endif
+}
+
+/* UnicodeEquals */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+#if PY_MAJOR_VERSION < 3
+    PyObject* owned_ref = NULL;
+#endif
+    int s1_is_unicode, s2_is_unicode;
+    if (s1 == s2) {
+        goto return_eq;
+    }
+    s1_is_unicode = PyUnicode_CheckExact(s1);
+    s2_is_unicode = PyUnicode_CheckExact(s2);
+#if PY_MAJOR_VERSION < 3
+    if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) {
+        owned_ref = PyUnicode_FromObject(s2);
+        if (unlikely(!owned_ref))
+            return -1;
+        s2 = owned_ref;
+        s2_is_unicode = 1;
+    } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) {
+        owned_ref = PyUnicode_FromObject(s1);
+        if (unlikely(!owned_ref))
+            return -1;
+        s1 = owned_ref;
+        s1_is_unicode = 1;
+    } else if (((!s2_is_unicode) & (!s1_is_unicode))) {
+        return __Pyx_PyBytes_Equals(s1, s2, equals);
+    }
+#endif
+    if (s1_is_unicode & s2_is_unicode) {
+        Py_ssize_t length;
+        int kind;
+        void *data1, *data2;
+        if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0))
+            return -1;
+        length = __Pyx_PyUnicode_GET_LENGTH(s1);
+        if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) {
+            goto return_ne;
+        }
+        kind = __Pyx_PyUnicode_KIND(s1);
+        if (kind != __Pyx_PyUnicode_KIND(s2)) {
+            goto return_ne;
+        }
+        data1 = __Pyx_PyUnicode_DATA(s1);
+        data2 = __Pyx_PyUnicode_DATA(s2);
+        if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) {
+            goto return_ne;
+        } else if (length == 1) {
+            goto return_eq;
+        } else {
+            int result = memcmp(data1, data2, (size_t)(length * kind));
+            #if PY_MAJOR_VERSION < 3
+            Py_XDECREF(owned_ref);
+            #endif
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & s2_is_unicode) {
+        goto return_ne;
+    } else if ((s2 == Py_None) & s1_is_unicode) {
+        goto return_ne;
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+return_eq:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_EQ);
+return_ne:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_NE);
+#endif
+}
+
+/* PyObjectCall */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *result;
+    ternaryfunc call = func->ob_type->tp_call;
+    if (unlikely(!call))
+        return PyObject_Call(func, arg, kw);
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    result = (*call)(func, arg, kw);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
+#endif
+
+/* PyErrFetchRestore */
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->curexc_type;
+    tmp_value = tstate->curexc_value;
+    tmp_tb = tstate->curexc_traceback;
+    tstate->curexc_type = type;
+    tstate->curexc_value = value;
+    tstate->curexc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+}
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+    *type = tstate->curexc_type;
+    *value = tstate->curexc_value;
+    *tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+}
+#endif
+
+/* RaiseException */
+#if PY_MAJOR_VERSION < 3
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
+                        CYTHON_UNUSED PyObject *cause) {
+    __Pyx_PyThreadState_declare
+    Py_XINCREF(type);
+    if (!value || value == Py_None)
+        value = NULL;
+    else
+        Py_INCREF(value);
+    if (!tb || tb == Py_None)
+        tb = NULL;
+    else {
+        Py_INCREF(tb);
+        if (!PyTraceBack_Check(tb)) {
+            PyErr_SetString(PyExc_TypeError,
+                "raise: arg 3 must be a traceback or None");
+            goto raise_error;
+        }
+    }
+    if (PyType_Check(type)) {
+#if CYTHON_COMPILING_IN_PYPY
+        if (!value) {
+            Py_INCREF(Py_None);
+            value = Py_None;
+        }
+#endif
+        PyErr_NormalizeException(&type, &value, &tb);
+    } else {
+        if (value) {
+            PyErr_SetString(PyExc_TypeError,
+                "instance exception may not have a separate value");
+            goto raise_error;
+        }
+        value = type;
+        type = (PyObject*) Py_TYPE(type);
+        Py_INCREF(type);
+        if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
+            PyErr_SetString(PyExc_TypeError,
+                "raise: exception class must be a subclass of BaseException");
+            goto raise_error;
+        }
+    }
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrRestore(type, value, tb);
+    return;
+raise_error:
+    Py_XDECREF(value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+    return;
+}
+#else
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
+    PyObject* owned_instance = NULL;
+    if (tb == Py_None) {
+        tb = 0;
+    } else if (tb && !PyTraceBack_Check(tb)) {
+        PyErr_SetString(PyExc_TypeError,
+            "raise: arg 3 must be a traceback or None");
+        goto bad;
+    }
+    if (value == Py_None)
+        value = 0;
+    if (PyExceptionInstance_Check(type)) {
+        if (value) {
+            PyErr_SetString(PyExc_TypeError,
+                "instance exception may not have a separate value");
+            goto bad;
+        }
+        value = type;
+        type = (PyObject*) Py_TYPE(value);
+    } else if (PyExceptionClass_Check(type)) {
+        PyObject *instance_class = NULL;
+        if (value && PyExceptionInstance_Check(value)) {
+            instance_class = (PyObject*) Py_TYPE(value);
+            if (instance_class != type) {
+                int is_subclass = PyObject_IsSubclass(instance_class, type);
+                if (!is_subclass) {
+                    instance_class = NULL;
+                } else if (unlikely(is_subclass == -1)) {
+                    goto bad;
+                } else {
+                    type = instance_class;
+                }
+            }
+        }
+        if (!instance_class) {
+            PyObject *args;
+            if (!value)
+                args = PyTuple_New(0);
+            else if (PyTuple_Check(value)) {
+                Py_INCREF(value);
+                args = value;
+            } else
+                args = PyTuple_Pack(1, value);
+            if (!args)
+                goto bad;
+            owned_instance = PyObject_Call(type, args, NULL);
+            Py_DECREF(args);
+            if (!owned_instance)
+                goto bad;
+            value = owned_instance;
+            if (!PyExceptionInstance_Check(value)) {
+                PyErr_Format(PyExc_TypeError,
+                             "calling %R should have returned an instance of "
+                             "BaseException, not %R",
+                             type, Py_TYPE(value));
+                goto bad;
+            }
+        }
+    } else {
+        PyErr_SetString(PyExc_TypeError,
+            "raise: exception class must be a subclass of BaseException");
+        goto bad;
+    }
+#if PY_VERSION_HEX >= 0x03030000
+    if (cause) {
+#else
+    if (cause && cause != Py_None) {
+#endif
+        PyObject *fixed_cause;
+        if (cause == Py_None) {
+            fixed_cause = NULL;
+        } else if (PyExceptionClass_Check(cause)) {
+            fixed_cause = PyObject_CallObject(cause, NULL);
+            if (fixed_cause == NULL)
+                goto bad;
+        } else if (PyExceptionInstance_Check(cause)) {
+            fixed_cause = cause;
+            Py_INCREF(fixed_cause);
+        } else {
+            PyErr_SetString(PyExc_TypeError,
+                            "exception causes must derive from "
+                            "BaseException");
+            goto bad;
+        }
+        PyException_SetCause(value, fixed_cause);
+    }
+    PyErr_SetObject(type, value);
+    if (tb) {
+#if CYTHON_COMPILING_IN_PYPY
+        PyObject *tmp_type, *tmp_value, *tmp_tb;
+        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
+        Py_INCREF(tb);
+        PyErr_Restore(tmp_type, tmp_value, tb);
+        Py_XDECREF(tmp_tb);
+#else
+        PyThreadState *tstate = PyThreadState_GET();
+        PyObject* tmp_tb = tstate->curexc_traceback;
+        if (tb != tmp_tb) {
+            Py_INCREF(tb);
+            tstate->curexc_traceback = tb;
+            Py_XDECREF(tmp_tb);
+        }
+#endif
+    }
+bad:
+    Py_XDECREF(owned_instance);
+    return;
+}
+#endif
+
+/* ExtTypeTest */
+  static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
+    if (unlikely(!type)) {
+        PyErr_SetString(PyExc_SystemError, "Missing type object");
+        return 0;
+    }
+    if (likely(PyObject_TypeCheck(obj, type)))
+        return 1;
+    PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s",
+                 Py_TYPE(obj)->tp_name, type->tp_name);
+    return 0;
+}
+
+/* ArgTypeTest */
+  static void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) {
+    PyErr_Format(PyExc_TypeError,
+        "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)",
+        name, type->tp_name, Py_TYPE(obj)->tp_name);
+}
+static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,
+    const char *name, int exact)
+{
+    if (unlikely(!type)) {
+        PyErr_SetString(PyExc_SystemError, "Missing type object");
+        return 0;
+    }
+    if (none_allowed && obj == Py_None) return 1;
+    else if (exact) {
+        if (likely(Py_TYPE(obj) == type)) return 1;
+        #if PY_MAJOR_VERSION == 2
+        else if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1;
+        #endif
+    }
+    else {
+        if (likely(PyObject_TypeCheck(obj, type))) return 1;
+    }
+    __Pyx_RaiseArgumentTypeInvalid(name, obj, type);
+    return 0;
+}
+
+/* PyIntBinop */
+  #if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) {
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact(op1))) {
+        const long b = intval;
+        long x;
+        long a = PyInt_AS_LONG(op1);
+            x = (long)((unsigned long)a + b);
+            if (likely((x^a) >= 0 || (x^b) >= 0))
+                return PyInt_FromLong(x);
+            return PyLong_Type.tp_as_number->nb_add(op1, op2);
+    }
+    #endif
+    #if CYTHON_USE_PYLONG_INTERNALS
+    if (likely(PyLong_CheckExact(op1))) {
+        const long b = intval;
+        long a, x;
+#ifdef HAVE_LONG_LONG
+        const PY_LONG_LONG llb = intval;
+        PY_LONG_LONG lla, llx;
+#endif
+        const digit* digits = ((PyLongObject*)op1)->ob_digit;
+        const Py_ssize_t size = Py_SIZE(op1);
+        if (likely(__Pyx_sst_abs(size) <= 1)) {
+            a = likely(size) ? digits[0] : 0;
+            if (size == -1) a = -a;
+        } else {
+            switch (size) {
+                case -2:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                case 2:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                case -3:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                case 3:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                case -4:
+                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                case 4:
+                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                default: return PyLong_Type.tp_as_number->nb_add(op1, op2);
+            }
+        }
+                x = a + b;
+            return PyLong_FromLong(x);
+#ifdef HAVE_LONG_LONG
+        long_long:
+                llx = lla + llb;
+            return PyLong_FromLongLong(llx);
+#endif
+        
+        
+    }
+    #endif
+    if (PyFloat_CheckExact(op1)) {
+        const long b = intval;
+        double a = PyFloat_AS_DOUBLE(op1);
+            double result;
+            PyFPE_START_PROTECT("add", return NULL)
+            result = ((double)a) + (double)b;
+            PyFPE_END_PROTECT(result)
+            return PyFloat_FromDouble(result);
+    }
+    return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2);
+}
+#endif
+
+/* PyIntBinop */
+  #if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) {
+    if (op1 == op2) {
+        Py_RETURN_TRUE;
+    }
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact(op1))) {
+        const long b = intval;
+        long a = PyInt_AS_LONG(op1);
+        if (a == b) {
+            Py_RETURN_TRUE;
+        } else {
+            Py_RETURN_FALSE;
+        }
+    }
+    #endif
+    #if CYTHON_USE_PYLONG_INTERNALS
+    if (likely(PyLong_CheckExact(op1))) {
+        const long b = intval;
+        long a;
+        const digit* digits = ((PyLongObject*)op1)->ob_digit;
+        const Py_ssize_t size = Py_SIZE(op1);
+        if (likely(__Pyx_sst_abs(size) <= 1)) {
+            a = likely(size) ? digits[0] : 0;
+            if (size == -1) a = -a;
+        } else {
+            switch (size) {
+                case -2:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+                    }
+                case 2:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+                    }
+                case -3:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+                    }
+                case 3:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+                    }
+                case -4:
+                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+                    }
+                case 4:
+                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+                    }
+                #if PyLong_SHIFT < 30 && PyLong_SHIFT != 15
+                default: return PyLong_Type.tp_richcompare(op1, op2, Py_EQ);
+                #else
+                default: Py_RETURN_FALSE;
+                #endif
+            }
+        }
+            if (a == b) {
+                Py_RETURN_TRUE;
+            } else {
+                Py_RETURN_FALSE;
+            }
+    }
+    #endif
+    if (PyFloat_CheckExact(op1)) {
+        const long b = intval;
+        double a = PyFloat_AS_DOUBLE(op1);
+            if ((double)a == (double)b) {
+                Py_RETURN_TRUE;
+            } else {
+                Py_RETURN_FALSE;
+            }
+    }
+    return PyObject_RichCompare(op1, op2, Py_EQ);
+}
+#endif
+
+/* GetModuleGlobalName */
+  static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) {
+    PyObject *result;
+#if !CYTHON_AVOID_BORROWED_REFS
+    result = PyDict_GetItem(__pyx_d, name);
+    if (likely(result)) {
+        Py_INCREF(result);
+    } else {
+#else
+    result = PyObject_GetItem(__pyx_d, name);
+    if (!result) {
+        PyErr_Clear();
+#endif
+        result = __Pyx_GetBuiltinName(name);
+    }
+    return result;
+}
+
+/* PyCFunctionFastCall */
+    #if CYTHON_FAST_PYCCALL
+static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) {
+    PyCFunctionObject *func = (PyCFunctionObject*)func_obj;
+    PyCFunction meth = PyCFunction_GET_FUNCTION(func);
+    PyObject *self = PyCFunction_GET_SELF(func);
+    assert(PyCFunction_Check(func));
+    assert(METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST)));
+    assert(nargs >= 0);
+    assert(nargs == 0 || args != NULL);
+    /* _PyCFunction_FastCallDict() must not be called with an exception set,
+       because it may clear it (directly or indirectly) and so the
+       caller loses its exception */
+    assert(!PyErr_Occurred());
+    return (*((__Pyx_PyCFunctionFast)meth)) (self, args, nargs, NULL);
+}
+#endif  // CYTHON_FAST_PYCCALL
+
+/* PyFunctionFastCall */
+    #if CYTHON_FAST_PYCALL
+#include "frameobject.h"
+static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
+                                               PyObject *globals) {
+    PyFrameObject *f;
+    PyThreadState *tstate = PyThreadState_GET();
+    PyObject **fastlocals;
+    Py_ssize_t i;
+    PyObject *result;
+    assert(globals != NULL);
+    /* XXX Perhaps we should create a specialized
+       PyFrame_New() that doesn't take locals, but does
+       take builtins without sanity checking them.
+       */
+    assert(tstate != NULL);
+    f = PyFrame_New(tstate, co, globals, NULL);
+    if (f == NULL) {
+        return NULL;
+    }
+    fastlocals = f->f_localsplus;
+    for (i = 0; i < na; i++) {
+        Py_INCREF(*args);
+        fastlocals[i] = *args++;
+    }
+    result = PyEval_EvalFrameEx(f,0);
+    ++tstate->recursion_depth;
+    Py_DECREF(f);
+    --tstate->recursion_depth;
+    return result;
+}
+#if 1 || PY_VERSION_HEX < 0x030600B1
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs) {
+    PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
+    PyObject *globals = PyFunction_GET_GLOBALS(func);
+    PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
+    PyObject *closure;
+#if PY_MAJOR_VERSION >= 3
+    PyObject *kwdefs;
+#endif
+    PyObject *kwtuple, **k;
+    PyObject **d;
+    Py_ssize_t nd;
+    Py_ssize_t nk;
+    PyObject *result;
+    assert(kwargs == NULL || PyDict_Check(kwargs));
+    nk = kwargs ? PyDict_Size(kwargs) : 0;
+    if (Py_EnterRecursiveCall((char*)" while calling a Python object")) {
+        return NULL;
+    }
+    if (
+#if PY_MAJOR_VERSION >= 3
+            co->co_kwonlyargcount == 0 &&
+#endif
+            likely(kwargs == NULL || nk == 0) &&
+            co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
+        if (argdefs == NULL && co->co_argcount == nargs) {
+            result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals);
+            goto done;
+        }
+        else if (nargs == 0 && argdefs != NULL
+                 && co->co_argcount == Py_SIZE(argdefs)) {
+            /* function called with no arguments, but all parameters have
+               a default value: use default values as arguments .*/
+            args = &PyTuple_GET_ITEM(argdefs, 0);
+            result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals);
+            goto done;
+        }
+    }
+    if (kwargs != NULL) {
+        Py_ssize_t pos, i;
+        kwtuple = PyTuple_New(2 * nk);
+        if (kwtuple == NULL) {
+            result = NULL;
+            goto done;
+        }
+        k = &PyTuple_GET_ITEM(kwtuple, 0);
+        pos = i = 0;
+        while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) {
+            Py_INCREF(k[i]);
+            Py_INCREF(k[i+1]);
+            i += 2;
+        }
+        nk = i / 2;
+    }
+    else {
+        kwtuple = NULL;
+        k = NULL;
+    }
+    closure = PyFunction_GET_CLOSURE(func);
+#if PY_MAJOR_VERSION >= 3
+    kwdefs = PyFunction_GET_KW_DEFAULTS(func);
+#endif
+    if (argdefs != NULL) {
+        d = &PyTuple_GET_ITEM(argdefs, 0);
+        nd = Py_SIZE(argdefs);
+    }
+    else {
+        d = NULL;
+        nd = 0;
+    }
+#if PY_MAJOR_VERSION >= 3
+    result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL,
+                               args, nargs,
+                               k, (int)nk,
+                               d, (int)nd, kwdefs, closure);
+#else
+    result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL,
+                               args, nargs,
+                               k, (int)nk,
+                               d, (int)nd, closure);
+#endif
+    Py_XDECREF(kwtuple);
+done:
+    Py_LeaveRecursiveCall();
+    return result;
+}
+#endif  // CPython < 3.6
+#endif  // CYTHON_FAST_PYCALL
+
+/* PyObjectCallMethO */
+    #if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
+    PyObject *self, *result;
+    PyCFunction cfunc;
+    cfunc = PyCFunction_GET_FUNCTION(func);
+    self = PyCFunction_GET_SELF(func);
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    result = cfunc(self, arg);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
+#endif
+
+/* PyObjectCallOneArg */
+    #if CYTHON_COMPILING_IN_CPYTHON
+static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+    PyObject *result;
+    PyObject *args = PyTuple_New(1);
+    if (unlikely(!args)) return NULL;
+    Py_INCREF(arg);
+    PyTuple_SET_ITEM(args, 0, arg);
+    result = __Pyx_PyObject_Call(func, args, NULL);
+    Py_DECREF(args);
+    return result;
+}
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+#if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(func)) {
+        return __Pyx_PyFunction_FastCall(func, &arg, 1);
+    }
+#endif
+#ifdef __Pyx_CyFunction_USED
+    if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) {
+#else
+    if (likely(PyCFunction_Check(func))) {
+#endif
+        if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) {
+            return __Pyx_PyObject_CallMethO(func, arg);
+#if CYTHON_FAST_PYCCALL
+        } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) {
+            return __Pyx_PyCFunction_FastCall(func, &arg, 1);
+#endif
+        }
+    }
+    return __Pyx__PyObject_CallOneArg(func, arg);
+}
+#else
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+    PyObject *result;
+    PyObject *args = PyTuple_Pack(1, arg);
+    if (unlikely(!args)) return NULL;
+    result = __Pyx_PyObject_Call(func, args, NULL);
+    Py_DECREF(args);
+    return result;
+}
+#endif
+
+/* GetItemInt */
+      static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
+    PyObject *r;
+    if (!j) return NULL;
+    r = PyObject_GetItem(o, j);
+    Py_DECREF(j);
+    return r;
+}
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
+                                                              CYTHON_NCP_UNUSED int wraparound,
+                                                              CYTHON_NCP_UNUSED int boundscheck) {
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    if (wraparound & unlikely(i < 0)) i += PyList_GET_SIZE(o);
+    if ((!boundscheck) || likely((0 <= i) & (i < PyList_GET_SIZE(o)))) {
+        PyObject *r = PyList_GET_ITEM(o, i);
+        Py_INCREF(r);
+        return r;
+    }
+    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
+#else
+    return PySequence_GetItem(o, i);
+#endif
+}
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
+                                                              CYTHON_NCP_UNUSED int wraparound,
+                                                              CYTHON_NCP_UNUSED int boundscheck) {
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    if (wraparound & unlikely(i < 0)) i += PyTuple_GET_SIZE(o);
+    if ((!boundscheck) || likely((0 <= i) & (i < PyTuple_GET_SIZE(o)))) {
+        PyObject *r = PyTuple_GET_ITEM(o, i);
+        Py_INCREF(r);
+        return r;
+    }
+    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
+#else
+    return PySequence_GetItem(o, i);
+#endif
+}
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list,
+                                                     CYTHON_NCP_UNUSED int wraparound,
+                                                     CYTHON_NCP_UNUSED int boundscheck) {
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS
+    if (is_list || PyList_CheckExact(o)) {
+        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o);
+        if ((!boundscheck) || (likely((n >= 0) & (n < PyList_GET_SIZE(o))))) {
+            PyObject *r = PyList_GET_ITEM(o, n);
+            Py_INCREF(r);
+            return r;
+        }
+    }
+    else if (PyTuple_CheckExact(o)) {
+        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o);
+        if ((!boundscheck) || likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) {
+            PyObject *r = PyTuple_GET_ITEM(o, n);
+            Py_INCREF(r);
+            return r;
+        }
+    } else {
+        PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
+        if (likely(m && m->sq_item)) {
+            if (wraparound && unlikely(i < 0) && likely(m->sq_length)) {
+                Py_ssize_t l = m->sq_length(o);
+                if (likely(l >= 0)) {
+                    i += l;
+                } else {
+                    if (!PyErr_ExceptionMatches(PyExc_OverflowError))
+                        return NULL;
+                    PyErr_Clear();
+                }
+            }
+            return m->sq_item(o, i);
+        }
+    }
+#else
+    if (is_list || PySequence_Check(o)) {
+        return PySequence_GetItem(o, i);
+    }
+#endif
+    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
+}
+
+/* BufferFormatCheck */
+      static CYTHON_INLINE int __Pyx_IsLittleEndian(void) {
+  unsigned int n = 1;
+  return *(unsigned char*)(&n) != 0;
+}
+static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,
+                              __Pyx_BufFmt_StackElem* stack,
+                              __Pyx_TypeInfo* type) {
+  stack[0].field = &ctx->root;
+  stack[0].parent_offset = 0;
+  ctx->root.type = type;
+  ctx->root.name = "buffer dtype";
+  ctx->root.offset = 0;
+  ctx->head = stack;
+  ctx->head->field = &ctx->root;
+  ctx->fmt_offset = 0;
+  ctx->head->parent_offset = 0;
+  ctx->new_packmode = '@';
+  ctx->enc_packmode = '@';
+  ctx->new_count = 1;
+  ctx->enc_count = 0;
+  ctx->enc_type = 0;
+  ctx->is_complex = 0;
+  ctx->is_valid_array = 0;
+  ctx->struct_alignment = 0;
+  while (type->typegroup == 'S') {
+    ++ctx->head;
+    ctx->head->field = type->fields;
+    ctx->head->parent_offset = 0;
+    type = type->fields->type;
+  }
+}
+static int __Pyx_BufFmt_ParseNumber(const char** ts) {
+    int count;
+    const char* t = *ts;
+    if (*t < '0' || *t > '9') {
+      return -1;
+    } else {
+        count = *t++ - '0';
+        while (*t >= '0' && *t < '9') {
+            count *= 10;
+            count += *t++ - '0';
+        }
+    }
+    *ts = t;
+    return count;
+}
+static int __Pyx_BufFmt_ExpectNumber(const char **ts) {
+    int number = __Pyx_BufFmt_ParseNumber(ts);
+    if (number == -1)
+        PyErr_Format(PyExc_ValueError,\
+                     "Does not understand character buffer dtype format string ('%c')", **ts);
+    return number;
+}
+static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) {
+  PyErr_Format(PyExc_ValueError,
+               "Unexpected format string character: '%c'", ch);
+}
+static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) {
+  switch (ch) {
+    case 'c': return "'char'";
+    case 'b': return "'signed char'";
+    case 'B': return "'unsigned char'";
+    case 'h': return "'short'";
+    case 'H': return "'unsigned short'";
+    case 'i': return "'int'";
+    case 'I': return "'unsigned int'";
+    case 'l': return "'long'";
+    case 'L': return "'unsigned long'";
+    case 'q': return "'long long'";
+    case 'Q': return "'unsigned long long'";
+    case 'f': return (is_complex ? "'complex float'" : "'float'");
+    case 'd': return (is_complex ? "'complex double'" : "'double'");
+    case 'g': return (is_complex ? "'complex long double'" : "'long double'");
+    case 'T': return "a struct";
+    case 'O': return "Python object";
+    case 'P': return "a pointer";
+    case 's': case 'p': return "a string";
+    case 0: return "end";
+    default: return "unparseable format string";
+  }
+}
+static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) {
+  switch (ch) {
+    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
+    case 'h': case 'H': return 2;
+    case 'i': case 'I': case 'l': case 'L': return 4;
+    case 'q': case 'Q': return 8;
+    case 'f': return (is_complex ? 8 : 4);
+    case 'd': return (is_complex ? 16 : 8);
+    case 'g': {
+      PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g')..");
+      return 0;
+    }
+    case 'O': case 'P': return sizeof(void*);
+    default:
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+}
+static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) {
+  switch (ch) {
+    case 'c': case 'b': case 'B': case 's': case 'p': return 1;
+    case 'h': case 'H': return sizeof(short);
+    case 'i': case 'I': return sizeof(int);
+    case 'l': case 'L': return sizeof(long);
+    #ifdef HAVE_LONG_LONG
+    case 'q': case 'Q': return sizeof(PY_LONG_LONG);
+    #endif
+    case 'f': return sizeof(float) * (is_complex ? 2 : 1);
+    case 'd': return sizeof(double) * (is_complex ? 2 : 1);
+    case 'g': return sizeof(long double) * (is_complex ? 2 : 1);
+    case 'O': case 'P': return sizeof(void*);
+    default: {
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+  }
+}
+typedef struct { char c; short x; } __Pyx_st_short;
+typedef struct { char c; int x; } __Pyx_st_int;
+typedef struct { char c; long x; } __Pyx_st_long;
+typedef struct { char c; float x; } __Pyx_st_float;
+typedef struct { char c; double x; } __Pyx_st_double;
+typedef struct { char c; long double x; } __Pyx_st_longdouble;
+typedef struct { char c; void *x; } __Pyx_st_void_p;
+#ifdef HAVE_LONG_LONG
+typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong;
+#endif
+static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) {
+  switch (ch) {
+    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
+    case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short);
+    case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int);
+    case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long);
+#ifdef HAVE_LONG_LONG
+    case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG);
+#endif
+    case 'f': return sizeof(__Pyx_st_float) - sizeof(float);
+    case 'd': return sizeof(__Pyx_st_double) - sizeof(double);
+    case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double);
+    case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*);
+    default:
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+}
+/* These are for computing the padding at the end of the struct to align
+   on the first member of the struct. This will probably the same as above,
+   but we don't have any guarantees.
+ */
+typedef struct { short x; char c; } __Pyx_pad_short;
+typedef struct { int x; char c; } __Pyx_pad_int;
+typedef struct { long x; char c; } __Pyx_pad_long;
+typedef struct { float x; char c; } __Pyx_pad_float;
+typedef struct { double x; char c; } __Pyx_pad_double;
+typedef struct { long double x; char c; } __Pyx_pad_longdouble;
+typedef struct { void *x; char c; } __Pyx_pad_void_p;
+#ifdef HAVE_LONG_LONG
+typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong;
+#endif
+static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) {
+  switch (ch) {
+    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
+    case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short);
+    case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int);
+    case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long);
+#ifdef HAVE_LONG_LONG
+    case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG);
+#endif
+    case 'f': return sizeof(__Pyx_pad_float) - sizeof(float);
+    case 'd': return sizeof(__Pyx_pad_double) - sizeof(double);
+    case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double);
+    case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*);
+    default:
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+}
+static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) {
+  switch (ch) {
+    case 'c':
+        return 'H';
+    case 'b': case 'h': case 'i':
+    case 'l': case 'q': case 's': case 'p':
+        return 'I';
+    case 'B': case 'H': case 'I': case 'L': case 'Q':
+        return 'U';
+    case 'f': case 'd': case 'g':
+        return (is_complex ? 'C' : 'R');
+    case 'O':
+        return 'O';
+    case 'P':
+        return 'P';
+    default: {
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+  }
+}
+static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) {
+  if (ctx->head == NULL || ctx->head->field == &ctx->root) {
+    const char* expected;
+    const char* quote;
+    if (ctx->head == NULL) {
+      expected = "end";
+      quote = "";
+    } else {
+      expected = ctx->head->field->type->name;
+      quote = "'";
+    }
+    PyErr_Format(PyExc_ValueError,
+                 "Buffer dtype mismatch, expected %s%s%s but got %s",
+                 quote, expected, quote,
+                 __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex));
+  } else {
+    __Pyx_StructField* field = ctx->head->field;
+    __Pyx_StructField* parent = (ctx->head - 1)->field;
+    PyErr_Format(PyExc_ValueError,
+                 "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'",
+                 field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex),
+                 parent->type->name, field->name);
+  }
+}
+static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) {
+  char group;
+  size_t size, offset, arraysize = 1;
+  if (ctx->enc_type == 0) return 0;
+  if (ctx->head->field->type->arraysize[0]) {
+    int i, ndim = 0;
+    if (ctx->enc_type == 's' || ctx->enc_type == 'p') {
+        ctx->is_valid_array = ctx->head->field->type->ndim == 1;
+        ndim = 1;
+        if (ctx->enc_count != ctx->head->field->type->arraysize[0]) {
+            PyErr_Format(PyExc_ValueError,
+                         "Expected a dimension of size %zu, got %zu",
+                         ctx->head->field->type->arraysize[0], ctx->enc_count);
+            return -1;
+        }
+    }
+    if (!ctx->is_valid_array) {
+      PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d",
+                   ctx->head->field->type->ndim, ndim);
+      return -1;
+    }
+    for (i = 0; i < ctx->head->field->type->ndim; i++) {
+      arraysize *= ctx->head->field->type->arraysize[i];
+    }
+    ctx->is_valid_array = 0;
+    ctx->enc_count = 1;
+  }
+  group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex);
+  do {
+    __Pyx_StructField* field = ctx->head->field;
+    __Pyx_TypeInfo* type = field->type;
+    if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') {
+      size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex);
+    } else {
+      size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex);
+    }
+    if (ctx->enc_packmode == '@') {
+      size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex);
+      size_t align_mod_offset;
+      if (align_at == 0) return -1;
+      align_mod_offset = ctx->fmt_offset % align_at;
+      if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset;
+      if (ctx->struct_alignment == 0)
+          ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type,
+                                                                 ctx->is_complex);
+    }
+    if (type->size != size || type->typegroup != group) {
+      if (type->typegroup == 'C' && type->fields != NULL) {
+        size_t parent_offset = ctx->head->parent_offset + field->offset;
+        ++ctx->head;
+        ctx->head->field = type->fields;
+        ctx->head->parent_offset = parent_offset;
+        continue;
+      }
+      if ((type->typegroup == 'H' || group == 'H') && type->size == size) {
+      } else {
+          __Pyx_BufFmt_RaiseExpected(ctx);
+          return -1;
+      }
+    }
+    offset = ctx->head->parent_offset + field->offset;
+    if (ctx->fmt_offset != offset) {
+      PyErr_Format(PyExc_ValueError,
+                   "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected",
+                   (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset);
+      return -1;
+    }
+    ctx->fmt_offset += size;
+    if (arraysize)
+      ctx->fmt_offset += (arraysize - 1) * size;
+    --ctx->enc_count;
+    while (1) {
+      if (field == &ctx->root) {
+        ctx->head = NULL;
+        if (ctx->enc_count != 0) {
+          __Pyx_BufFmt_RaiseExpected(ctx);
+          return -1;
+        }
+        break;
+      }
+      ctx->head->field = ++field;
+      if (field->type == NULL) {
+        --ctx->head;
+        field = ctx->head->field;
+        continue;
+      } else if (field->type->typegroup == 'S') {
+        size_t parent_offset = ctx->head->parent_offset + field->offset;
+        if (field->type->fields->type == NULL) continue;
+        field = field->type->fields;
+        ++ctx->head;
+        ctx->head->field = field;
+        ctx->head->parent_offset = parent_offset;
+        break;
+      } else {
+        break;
+      }
+    }
+  } while (ctx->enc_count);
+  ctx->enc_type = 0;
+  ctx->is_complex = 0;
+  return 0;
+}
+static CYTHON_INLINE PyObject *
+__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp)
+{
+    const char *ts = *tsp;
+    int i = 0, number;
+    int ndim = ctx->head->field->type->ndim;
+;
+    ++ts;
+    if (ctx->new_count != 1) {
+        PyErr_SetString(PyExc_ValueError,
+                        "Cannot handle repeated arrays in format string");
+        return NULL;
+    }
+    if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+    while (*ts && *ts != ')') {
+        switch (*ts) {
+            case ' ': case '\f': case '\r': case '\n': case '\t': case '\v':  continue;
+            default:  break;
+        }
+        number = __Pyx_BufFmt_ExpectNumber(&ts);
+        if (number == -1) return NULL;
+        if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i])
+            return PyErr_Format(PyExc_ValueError,
+                        "Expected a dimension of size %zu, got %d",
+                        ctx->head->field->type->arraysize[i], number);
+        if (*ts != ',' && *ts != ')')
+            return PyErr_Format(PyExc_ValueError,
+                                "Expected a comma in format string, got '%c'", *ts);
+        if (*ts == ',') ts++;
+        i++;
+    }
+    if (i != ndim)
+        return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d",
+                            ctx->head->field->type->ndim, i);
+    if (!*ts) {
+        PyErr_SetString(PyExc_ValueError,
+                        "Unexpected end of format string, expected ')'");
+        return NULL;
+    }
+    ctx->is_valid_array = 1;
+    ctx->new_count = 1;
+    *tsp = ++ts;
+    return Py_None;
+}
+static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) {
+  int got_Z = 0;
+  while (1) {
+    switch(*ts) {
+      case 0:
+        if (ctx->enc_type != 0 && ctx->head == NULL) {
+          __Pyx_BufFmt_RaiseExpected(ctx);
+          return NULL;
+        }
+        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+        if (ctx->head != NULL) {
+          __Pyx_BufFmt_RaiseExpected(ctx);
+          return NULL;
+        }
+        return ts;
+      case ' ':
+      case '\r':
+      case '\n':
+        ++ts;
+        break;
+      case '<':
+        if (!__Pyx_IsLittleEndian()) {
+          PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler");
+          return NULL;
+        }
+        ctx->new_packmode = '=';
+        ++ts;
+        break;
+      case '>':
+      case '!':
+        if (__Pyx_IsLittleEndian()) {
+          PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler");
+          return NULL;
+        }
+        ctx->new_packmode = '=';
+        ++ts;
+        break;
+      case '=':
+      case '@':
+      case '^':
+        ctx->new_packmode = *ts++;
+        break;
+      case 'T':
+        {
+          const char* ts_after_sub;
+          size_t i, struct_count = ctx->new_count;
+          size_t struct_alignment = ctx->struct_alignment;
+          ctx->new_count = 1;
+          ++ts;
+          if (*ts != '{') {
+            PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'");
+            return NULL;
+          }
+          if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+          ctx->enc_type = 0;
+          ctx->enc_count = 0;
+          ctx->struct_alignment = 0;
+          ++ts;
+          ts_after_sub = ts;
+          for (i = 0; i != struct_count; ++i) {
+            ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts);
+            if (!ts_after_sub) return NULL;
+          }
+          ts = ts_after_sub;
+          if (struct_alignment) ctx->struct_alignment = struct_alignment;
+        }
+        break;
+      case '}':
+        {
+          size_t alignment = ctx->struct_alignment;
+          ++ts;
+          if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+          ctx->enc_type = 0;
+          if (alignment && ctx->fmt_offset % alignment) {
+            ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment);
+          }
+        }
+        return ts;
+      case 'x':
+        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+        ctx->fmt_offset += ctx->new_count;
+        ctx->new_count = 1;
+        ctx->enc_count = 0;
+        ctx->enc_type = 0;
+        ctx->enc_packmode = ctx->new_packmode;
+        ++ts;
+        break;
+      case 'Z':
+        got_Z = 1;
+        ++ts;
+        if (*ts != 'f' && *ts != 'd' && *ts != 'g') {
+          __Pyx_BufFmt_RaiseUnexpectedChar('Z');
+          return NULL;
+        }
+      case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I':
+      case 'l': case 'L': case 'q': case 'Q':
+      case 'f': case 'd': case 'g':
+      case 'O': case 'p':
+        if (ctx->enc_type == *ts && got_Z == ctx->is_complex &&
+            ctx->enc_packmode == ctx->new_packmode) {
+          ctx->enc_count += ctx->new_count;
+          ctx->new_count = 1;
+          got_Z = 0;
+          ++ts;
+          break;
+        }
+      case 's':
+        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+        ctx->enc_count = ctx->new_count;
+        ctx->enc_packmode = ctx->new_packmode;
+        ctx->enc_type = *ts;
+        ctx->is_complex = got_Z;
+        ++ts;
+        ctx->new_count = 1;
+        got_Z = 0;
+        break;
+      case ':':
+        ++ts;
+        while(*ts != ':') ++ts;
+        ++ts;
+        break;
+      case '(':
+        if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL;
+        break;
+      default:
+        {
+          int number = __Pyx_BufFmt_ExpectNumber(&ts);
+          if (number == -1) return NULL;
+          ctx->new_count = (size_t)number;
+        }
+    }
+  }
+}
+static CYTHON_INLINE void __Pyx_ZeroBuffer(Py_buffer* buf) {
+  buf->buf = NULL;
+  buf->obj = NULL;
+  buf->strides = __Pyx_zeros;
+  buf->shape = __Pyx_zeros;
+  buf->suboffsets = __Pyx_minusones;
+}
+static CYTHON_INLINE int __Pyx_GetBufferAndValidate(
+        Py_buffer* buf, PyObject* obj,  __Pyx_TypeInfo* dtype, int flags,
+        int nd, int cast, __Pyx_BufFmt_StackElem* stack)
+{
+  if (obj == Py_None || obj == NULL) {
+    __Pyx_ZeroBuffer(buf);
+    return 0;
+  }
+  buf->buf = NULL;
+  if (__Pyx_GetBuffer(obj, buf, flags) == -1) goto fail;
+  if (buf->ndim != nd) {
+    PyErr_Format(PyExc_ValueError,
+                 "Buffer has wrong number of dimensions (expected %d, got %d)",
+                 nd, buf->ndim);
+    goto fail;
+  }
+  if (!cast) {
+    __Pyx_BufFmt_Context ctx;
+    __Pyx_BufFmt_Init(&ctx, stack, dtype);
+    if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail;
+  }
+  if ((unsigned)buf->itemsize != dtype->size) {
+    PyErr_Format(PyExc_ValueError,
+      "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)",
+      buf->itemsize, (buf->itemsize > 1) ? "s" : "",
+      dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : "");
+    goto fail;
+  }
+  if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones;
+  return 0;
+fail:;
+  __Pyx_ZeroBuffer(buf);
+  return -1;
+}
+static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) {
+  if (info->buf == NULL) return;
+  if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL;
+  __Pyx_ReleaseBuffer(info);
+}
+
+/* FetchCommonType */
+        static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
+    PyObject* fake_module;
+    PyTypeObject* cached_type = NULL;
+    fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI);
+    if (!fake_module) return NULL;
+    Py_INCREF(fake_module);
+    cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name);
+    if (cached_type) {
+        if (!PyType_Check((PyObject*)cached_type)) {
+            PyErr_Format(PyExc_TypeError,
+                "Shared Cython type %.200s is not a type object",
+                type->tp_name);
+            goto bad;
+        }
+        if (cached_type->tp_basicsize != type->tp_basicsize) {
+            PyErr_Format(PyExc_TypeError,
+                "Shared Cython type %.200s has the wrong size, try recompiling",
+                type->tp_name);
+            goto bad;
+        }
+    } else {
+        if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+        PyErr_Clear();
+        if (PyType_Ready(type) < 0) goto bad;
+        if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0)
+            goto bad;
+        Py_INCREF(type);
+        cached_type = type;
+    }
+done:
+    Py_DECREF(fake_module);
+    return cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+
+/* CythonFunction */
+        static PyObject *
+__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure)
+{
+    if (unlikely(op->func_doc == NULL)) {
+        if (op->func.m_ml->ml_doc) {
+#if PY_MAJOR_VERSION >= 3
+            op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc);
+#else
+            op->func_doc = PyString_FromString(op->func.m_ml->ml_doc);
+#endif
+            if (unlikely(op->func_doc == NULL))
+                return NULL;
+        } else {
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
+    }
+    Py_INCREF(op->func_doc);
+    return op->func_doc;
+}
+static int
+__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value)
+{
+    PyObject *tmp = op->func_doc;
+    if (value == NULL) {
+        value = Py_None;
+    }
+    Py_INCREF(value);
+    op->func_doc = value;
+    Py_XDECREF(tmp);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op)
+{
+    if (unlikely(op->func_name == NULL)) {
+#if PY_MAJOR_VERSION >= 3
+        op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name);
+#else
+        op->func_name = PyString_InternFromString(op->func.m_ml->ml_name);
+#endif
+        if (unlikely(op->func_name == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_name);
+    return op->func_name;
+}
+static int
+__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value)
+{
+    PyObject *tmp;
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value))) {
+#else
+    if (unlikely(value == NULL || !PyString_Check(value))) {
+#endif
+        PyErr_SetString(PyExc_TypeError,
+                        "__name__ must be set to a string object");
+        return -1;
+    }
+    tmp = op->func_name;
+    Py_INCREF(value);
+    op->func_name = value;
+    Py_XDECREF(tmp);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op)
+{
+    Py_INCREF(op->func_qualname);
+    return op->func_qualname;
+}
+static int
+__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value)
+{
+    PyObject *tmp;
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value))) {
+#else
+    if (unlikely(value == NULL || !PyString_Check(value))) {
+#endif
+        PyErr_SetString(PyExc_TypeError,
+                        "__qualname__ must be set to a string object");
+        return -1;
+    }
+    tmp = op->func_qualname;
+    Py_INCREF(value);
+    op->func_qualname = value;
+    Py_XDECREF(tmp);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_self(__pyx_CyFunctionObject *m, CYTHON_UNUSED void *closure)
+{
+    PyObject *self;
+    self = m->func_closure;
+    if (self == NULL)
+        self = Py_None;
+    Py_INCREF(self);
+    return self;
+}
+static PyObject *
+__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op)
+{
+    if (unlikely(op->func_dict == NULL)) {
+        op->func_dict = PyDict_New();
+        if (unlikely(op->func_dict == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_dict);
+    return op->func_dict;
+}
+static int
+__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value)
+{
+    PyObject *tmp;
+    if (unlikely(value == NULL)) {
+        PyErr_SetString(PyExc_TypeError,
+               "function's dictionary may not be deleted");
+        return -1;
+    }
+    if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+               "setting function's dictionary to a non-dict");
+        return -1;
+    }
+    tmp = op->func_dict;
+    Py_INCREF(value);
+    op->func_dict = value;
+    Py_XDECREF(tmp);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op)
+{
+    Py_INCREF(op->func_globals);
+    return op->func_globals;
+}
+static PyObject *
+__Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op)
+{
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+static PyObject *
+__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op)
+{
+    PyObject* result = (op->func_code) ? op->func_code : Py_None;
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
+    int result = 0;
+    PyObject *res = op->defaults_getter((PyObject *) op);
+    if (unlikely(!res))
+        return -1;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    op->defaults_tuple = PyTuple_GET_ITEM(res, 0);
+    Py_INCREF(op->defaults_tuple);
+    op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
+    Py_INCREF(op->defaults_kwdict);
+    #else
+    op->defaults_tuple = PySequence_ITEM(res, 0);
+    if (unlikely(!op->defaults_tuple)) result = -1;
+    else {
+        op->defaults_kwdict = PySequence_ITEM(res, 1);
+        if (unlikely(!op->defaults_kwdict)) result = -1;
+    }
+    #endif
+    Py_DECREF(res);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value) {
+    PyObject* tmp;
+    if (!value) {
+        value = Py_None;
+    } else if (value != Py_None && !PyTuple_Check(value)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__defaults__ must be set to a tuple object");
+        return -1;
+    }
+    Py_INCREF(value);
+    tmp = op->defaults_tuple;
+    op->defaults_tuple = value;
+    Py_XDECREF(tmp);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op) {
+    PyObject* result = op->defaults_tuple;
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL;
+            result = op->defaults_tuple;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value) {
+    PyObject* tmp;
+    if (!value) {
+        value = Py_None;
+    } else if (value != Py_None && !PyDict_Check(value)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__kwdefaults__ must be set to a dict object");
+        return -1;
+    }
+    Py_INCREF(value);
+    tmp = op->defaults_kwdict;
+    op->defaults_kwdict = value;
+    Py_XDECREF(tmp);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op) {
+    PyObject* result = op->defaults_kwdict;
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL;
+            result = op->defaults_kwdict;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value) {
+    PyObject* tmp;
+    if (!value || value == Py_None) {
+        value = NULL;
+    } else if (!PyDict_Check(value)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__annotations__ must be set to a dict object");
+        return -1;
+    }
+    Py_XINCREF(value);
+    tmp = op->func_annotations;
+    op->func_annotations = value;
+    Py_XDECREF(tmp);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op) {
+    PyObject* result = op->func_annotations;
+    if (unlikely(!result)) {
+        result = PyDict_New();
+        if (unlikely(!result)) return NULL;
+        op->func_annotations = result;
+    }
+    Py_INCREF(result);
+    return result;
+}
+static PyGetSetDef __pyx_CyFunction_getsets[] = {
+    {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "__doc__",  (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0},
+    {(char *) "__self__", (getter)__Pyx_CyFunction_get_self, 0, 0, 0},
+    {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0},
+    {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0},
+    {0, 0, 0, 0, 0}
+};
+static PyMemberDef __pyx_CyFunction_members[] = {
+    {(char *) "__module__", T_OBJECT, offsetof(__pyx_CyFunctionObject, func.m_module), PY_WRITE_RESTRICTED, 0},
+    {0, 0, 0,  0, 0}
+};
+static PyObject *
+__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args)
+{
+#if PY_MAJOR_VERSION >= 3
+    return PyUnicode_FromString(m->func.m_ml->ml_name);
+#else
+    return PyString_FromString(m->func.m_ml->ml_name);
+#endif
+}
+static PyMethodDef __pyx_CyFunction_methods[] = {
+    {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0},
+    {0, 0, 0, 0}
+};
+#if PY_VERSION_HEX < 0x030500A0
+#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist)
+#else
+#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist)
+#endif
+static PyObject *__Pyx_CyFunction_New(PyTypeObject *type, PyMethodDef *ml, int flags, PyObject* qualname,
+                                      PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+    __pyx_CyFunctionObject *op = PyObject_GC_New(__pyx_CyFunctionObject, type);
+    if (op == NULL)
+        return NULL;
+    op->flags = flags;
+    __Pyx_CyFunction_weakreflist(op) = NULL;
+    op->func.m_ml = ml;
+    op->func.m_self = (PyObject *) op;
+    Py_XINCREF(closure);
+    op->func_closure = closure;
+    Py_XINCREF(module);
+    op->func.m_module = module;
+    op->func_dict = NULL;
+    op->func_name = NULL;
+    Py_INCREF(qualname);
+    op->func_qualname = qualname;
+    op->func_doc = NULL;
+    op->func_classobj = NULL;
+    op->func_globals = globals;
+    Py_INCREF(op->func_globals);
+    Py_XINCREF(code);
+    op->func_code = code;
+    op->defaults_pyobjects = 0;
+    op->defaults = NULL;
+    op->defaults_tuple = NULL;
+    op->defaults_kwdict = NULL;
+    op->defaults_getter = NULL;
+    op->func_annotations = NULL;
+    PyObject_GC_Track(op);
+    return (PyObject *) op;
+}
+static int
+__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
+{
+    Py_CLEAR(m->func_closure);
+    Py_CLEAR(m->func.m_module);
+    Py_CLEAR(m->func_dict);
+    Py_CLEAR(m->func_name);
+    Py_CLEAR(m->func_qualname);
+    Py_CLEAR(m->func_doc);
+    Py_CLEAR(m->func_globals);
+    Py_CLEAR(m->func_code);
+    Py_CLEAR(m->func_classobj);
+    Py_CLEAR(m->defaults_tuple);
+    Py_CLEAR(m->defaults_kwdict);
+    Py_CLEAR(m->func_annotations);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_XDECREF(pydefaults[i]);
+        PyObject_Free(m->defaults);
+        m->defaults = NULL;
+    }
+    return 0;
+}
+static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    PyObject_GC_UnTrack(m);
+    if (__Pyx_CyFunction_weakreflist(m) != NULL)
+        PyObject_ClearWeakRefs((PyObject *) m);
+    __Pyx_CyFunction_clear(m);
+    PyObject_GC_Del(m);
+}
+static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg)
+{
+    Py_VISIT(m->func_closure);
+    Py_VISIT(m->func.m_module);
+    Py_VISIT(m->func_dict);
+    Py_VISIT(m->func_name);
+    Py_VISIT(m->func_qualname);
+    Py_VISIT(m->func_doc);
+    Py_VISIT(m->func_globals);
+    Py_VISIT(m->func_code);
+    Py_VISIT(m->func_classobj);
+    Py_VISIT(m->defaults_tuple);
+    Py_VISIT(m->defaults_kwdict);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_VISIT(pydefaults[i]);
+    }
+    return 0;
+}
+static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type)
+{
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) {
+        Py_INCREF(func);
+        return func;
+    }
+    if (m->flags & __Pyx_CYFUNCTION_CLASSMETHOD) {
+        if (type == NULL)
+            type = (PyObject *)(Py_TYPE(obj));
+        return __Pyx_PyMethod_New(func, type, (PyObject *)(Py_TYPE(type)));
+    }
+    if (obj == Py_None)
+        obj = NULL;
+    return __Pyx_PyMethod_New(func, obj, type);
+}
+static PyObject*
+__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op)
+{
+#if PY_MAJOR_VERSION >= 3
+    return PyUnicode_FromFormat("<cyfunction %U at %p>",
+                                op->func_qualname, (void *)op);
+#else
+    return PyString_FromFormat("<cyfunction %s at %p>",
+                               PyString_AsString(op->func_qualname), (void *)op);
+#endif
+}
+static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) {
+    PyCFunctionObject* f = (PyCFunctionObject*)func;
+    PyCFunction meth = f->m_ml->ml_meth;
+    Py_ssize_t size;
+    switch (f->m_ml->ml_flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) {
+    case METH_VARARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0))
+            return (*meth)(self, arg);
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        return (*(PyCFunctionWithKeywords)meth)(self, arg, kw);
+    case METH_NOARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+            size = PyTuple_GET_SIZE(arg);
+            if (likely(size == 0))
+                return (*meth)(self, NULL);
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+            return NULL;
+        }
+        break;
+    case METH_O:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+            size = PyTuple_GET_SIZE(arg);
+            if (likely(size == 1)) {
+                PyObject *result, *arg0 = PySequence_ITEM(arg, 0);
+                if (unlikely(!arg0)) return NULL;
+                result = (*meth)(self, arg0);
+                Py_DECREF(arg0);
+                return result;
+            }
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+            return NULL;
+        }
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags in "
+                        "__Pyx_CyFunction_Call. METH_OLDARGS is no "
+                        "longer supported!");
+        return NULL;
+    }
+    PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
+                 f->m_ml->ml_name);
+    return NULL;
+}
+static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    return __Pyx_CyFunction_CallMethod(func, ((PyCFunctionObject*)func)->m_self, arg, kw);
+}
+static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) {
+    PyObject *result;
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        Py_ssize_t argc;
+        PyObject *new_args;
+        PyObject *self;
+        argc = PyTuple_GET_SIZE(args);
+        new_args = PyTuple_GetSlice(args, 1, argc);
+        if (unlikely(!new_args))
+            return NULL;
+        self = PyTuple_GetItem(args, 0);
+        if (unlikely(!self)) {
+            Py_DECREF(new_args);
+            return NULL;
+        }
+        result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw);
+        Py_DECREF(new_args);
+    } else {
+        result = __Pyx_CyFunction_Call(func, args, kw);
+    }
+    return result;
+}
+static PyTypeObject __pyx_CyFunctionType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+    (destructor) __Pyx_CyFunction_dealloc,
+    0,
+    0,
+    0,
+#if PY_MAJOR_VERSION < 3
+    0,
+#else
+    0,
+#endif
+    (reprfunc) __Pyx_CyFunction_repr,
+    0,
+    0,
+    0,
+    0,
+    __Pyx_CyFunction_CallAsMethod,
+    0,
+    0,
+    0,
+    0,
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
+    0,
+    (traverseproc) __Pyx_CyFunction_traverse,
+    (inquiry) __Pyx_CyFunction_clear,
+    0,
+#if PY_VERSION_HEX < 0x030500A0
+    offsetof(__pyx_CyFunctionObject, func_weakreflist),
+#else
+    offsetof(PyCFunctionObject, m_weakreflist),
+#endif
+    0,
+    0,
+    __pyx_CyFunction_methods,
+    __pyx_CyFunction_members,
+    __pyx_CyFunction_getsets,
+    0,
+    0,
+    __Pyx_CyFunction_descr_get,
+    0,
+    offsetof(__pyx_CyFunctionObject, func_dict),
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+#if PY_VERSION_HEX >= 0x030400a1
+    0,
+#endif
+};
+static int __pyx_CyFunction_init(void) {
+    __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type);
+    if (__pyx_CyFunctionType == NULL) {
+        return -1;
+    }
+    return 0;
+}
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults = PyObject_Malloc(size);
+    if (!m->defaults)
+        return PyErr_NoMemory();
+    memset(m->defaults, 0, size);
+    m->defaults_pyobjects = pyobjects;
+    return m->defaults;
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_tuple = tuple;
+    Py_INCREF(tuple);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_kwdict = dict;
+    Py_INCREF(dict);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->func_annotations = dict;
+    Py_INCREF(dict);
+}
+
+/* BufferFallbackError */
+            static void __Pyx_RaiseBufferFallbackError(void) {
+  PyErr_SetString(PyExc_ValueError,
+     "Buffer acquisition failed on assignment; and then reacquiring the old buffer failed too!");
+}
+
+/* None */
+            static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t a, Py_ssize_t b) {
+    Py_ssize_t q = a / b;
+    Py_ssize_t r = a - q*b;
+    q -= ((r != 0) & ((r ^ b) < 0));
+    return q;
+}
+
+/* BufferIndexError */
+            static void __Pyx_RaiseBufferIndexError(int axis) {
+  PyErr_Format(PyExc_IndexError,
+     "Out of bounds on buffer access (axis %d)", axis);
+}
+
+/* RaiseTooManyValuesToUnpack */
+            static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
+    PyErr_Format(PyExc_ValueError,
+                 "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected);
+}
+
+/* RaiseNeedMoreValuesToUnpack */
+            static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
+    PyErr_Format(PyExc_ValueError,
+                 "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack",
+                 index, (index == 1) ? "" : "s");
+}
+
+/* RaiseNoneIterError */
+            static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+}
+
+/* SaveResetException */
+            #if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+    *type = tstate->exc_type;
+    *value = tstate->exc_value;
+    *tb = tstate->exc_traceback;
+    Py_XINCREF(*type);
+    Py_XINCREF(*value);
+    Py_XINCREF(*tb);
+}
+static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    tstate->exc_type = type;
+    tstate->exc_value = value;
+    tstate->exc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+}
+#endif
+
+/* PyErrExceptionMatches */
+            #if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
+    PyObject *exc_type = tstate->curexc_type;
+    if (exc_type == err) return 1;
+    if (unlikely(!exc_type)) return 0;
+    return PyErr_GivenExceptionMatches(exc_type, err);
+}
+#endif
+
+/* GetException */
+            #if CYTHON_FAST_THREAD_STATE
+static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+#else
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) {
+#endif
+    PyObject *local_type, *local_value, *local_tb;
+#if CYTHON_FAST_THREAD_STATE
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    local_type = tstate->curexc_type;
+    local_value = tstate->curexc_value;
+    local_tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+#else
+    PyErr_Fetch(&local_type, &local_value, &local_tb);
+#endif
+    PyErr_NormalizeException(&local_type, &local_value, &local_tb);
+#if CYTHON_FAST_THREAD_STATE
+    if (unlikely(tstate->curexc_type))
+#else
+    if (unlikely(PyErr_Occurred()))
+#endif
+        goto bad;
+    #if PY_MAJOR_VERSION >= 3
+    if (local_tb) {
+        if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0))
+            goto bad;
+    }
+    #endif
+    Py_XINCREF(local_tb);
+    Py_XINCREF(local_type);
+    Py_XINCREF(local_value);
+    *type = local_type;
+    *value = local_value;
+    *tb = local_tb;
+#if CYTHON_FAST_THREAD_STATE
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    tstate->exc_type = local_type;
+    tstate->exc_value = local_value;
+    tstate->exc_traceback = local_tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#else
+    PyErr_SetExcInfo(local_type, local_value, local_tb);
+#endif
+    return 0;
+bad:
+    *type = 0;
+    *value = 0;
+    *tb = 0;
+    Py_XDECREF(local_type);
+    Py_XDECREF(local_value);
+    Py_XDECREF(local_tb);
+    return -1;
+}
+
+/* Import */
+              static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
+    PyObject *empty_list = 0;
+    PyObject *module = 0;
+    PyObject *global_dict = 0;
+    PyObject *empty_dict = 0;
+    PyObject *list;
+    #if PY_VERSION_HEX < 0x03030000
+    PyObject *py_import;
+    py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import);
+    if (!py_import)
+        goto bad;
+    #endif
+    if (from_list)
+        list = from_list;
+    else {
+        empty_list = PyList_New(0);
+        if (!empty_list)
+            goto bad;
+        list = empty_list;
+    }
+    global_dict = PyModule_GetDict(__pyx_m);
+    if (!global_dict)
+        goto bad;
+    empty_dict = PyDict_New();
+    if (!empty_dict)
+        goto bad;
+    {
+        #if PY_MAJOR_VERSION >= 3
+        if (level == -1) {
+            if (strchr(__Pyx_MODULE_NAME, '.')) {
+                #if PY_VERSION_HEX < 0x03030000
+                PyObject *py_level = PyInt_FromLong(1);
+                if (!py_level)
+                    goto bad;
+                module = PyObject_CallFunctionObjArgs(py_import,
+                    name, global_dict, empty_dict, list, py_level, NULL);
+                Py_DECREF(py_level);
+                #else
+                module = PyImport_ImportModuleLevelObject(
+                    name, global_dict, empty_dict, list, 1);
+                #endif
+                if (!module) {
+                    if (!PyErr_ExceptionMatches(PyExc_ImportError))
+                        goto bad;
+                    PyErr_Clear();
+                }
+            }
+            level = 0;
+        }
+        #endif
+        if (!module) {
+            #if PY_VERSION_HEX < 0x03030000
+            PyObject *py_level = PyInt_FromLong(level);
+            if (!py_level)
+                goto bad;
+            module = PyObject_CallFunctionObjArgs(py_import,
+                name, global_dict, empty_dict, list, py_level, NULL);
+            Py_DECREF(py_level);
+            #else
+            module = PyImport_ImportModuleLevelObject(
+                name, global_dict, empty_dict, list, level);
+            #endif
+        }
+    }
+bad:
+    #if PY_VERSION_HEX < 0x03030000
+    Py_XDECREF(py_import);
+    #endif
+    Py_XDECREF(empty_list);
+    Py_XDECREF(empty_dict);
+    return module;
+}
+
+/* CodeObjectCache */
+              static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
+    int start = 0, mid = 0, end = count - 1;
+    if (end >= 0 && code_line > entries[end].code_line) {
+        return count;
+    }
+    while (start < end) {
+        mid = start + (end - start) / 2;
+        if (code_line < entries[mid].code_line) {
+            end = mid;
+        } else if (code_line > entries[mid].code_line) {
+             start = mid + 1;
+        } else {
+            return mid;
+        }
+    }
+    if (code_line <= entries[mid].code_line) {
+        return mid;
+    } else {
+        return mid + 1;
+    }
+}
+static PyCodeObject *__pyx_find_code_object(int code_line) {
+    PyCodeObject* code_object;
+    int pos;
+    if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) {
+        return NULL;
+    }
+    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
+    if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) {
+        return NULL;
+    }
+    code_object = __pyx_code_cache.entries[pos].code_object;
+    Py_INCREF(code_object);
+    return code_object;
+}
+static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
+    int pos, i;
+    __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries;
+    if (unlikely(!code_line)) {
+        return;
+    }
+    if (unlikely(!entries)) {
+        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry));
+        if (likely(entries)) {
+            __pyx_code_cache.entries = entries;
+            __pyx_code_cache.max_count = 64;
+            __pyx_code_cache.count = 1;
+            entries[0].code_line = code_line;
+            entries[0].code_object = code_object;
+            Py_INCREF(code_object);
+        }
+        return;
+    }
+    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
+    if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) {
+        PyCodeObject* tmp = entries[pos].code_object;
+        entries[pos].code_object = code_object;
+        Py_DECREF(tmp);
+        return;
+    }
+    if (__pyx_code_cache.count == __pyx_code_cache.max_count) {
+        int new_max = __pyx_code_cache.max_count + 64;
+        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc(
+            __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry));
+        if (unlikely(!entries)) {
+            return;
+        }
+        __pyx_code_cache.entries = entries;
+        __pyx_code_cache.max_count = new_max;
+    }
+    for (i=__pyx_code_cache.count; i>pos; i--) {
+        entries[i] = entries[i-1];
+    }
+    entries[pos].code_line = code_line;
+    entries[pos].code_object = code_object;
+    __pyx_code_cache.count++;
+    Py_INCREF(code_object);
+}
+
+/* AddTraceback */
+              #include "compile.h"
+#include "frameobject.h"
+#include "traceback.h"
+static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
+            const char *funcname, int c_line,
+            int py_line, const char *filename) {
+    PyCodeObject *py_code = 0;
+    PyObject *py_srcfile = 0;
+    PyObject *py_funcname = 0;
+    #if PY_MAJOR_VERSION < 3
+    py_srcfile = PyString_FromString(filename);
+    #else
+    py_srcfile = PyUnicode_FromString(filename);
+    #endif
+    if (!py_srcfile) goto bad;
+    if (c_line) {
+        #if PY_MAJOR_VERSION < 3
+        py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
+        #else
+        py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
+        #endif
+    }
+    else {
+        #if PY_MAJOR_VERSION < 3
+        py_funcname = PyString_FromString(funcname);
+        #else
+        py_funcname = PyUnicode_FromString(funcname);
+        #endif
+    }
+    if (!py_funcname) goto bad;
+    py_code = __Pyx_PyCode_New(
+        0,
+        0,
+        0,
+        0,
+        0,
+        __pyx_empty_bytes, /*PyObject *code,*/
+        __pyx_empty_tuple, /*PyObject *consts,*/
+        __pyx_empty_tuple, /*PyObject *names,*/
+        __pyx_empty_tuple, /*PyObject *varnames,*/
+        __pyx_empty_tuple, /*PyObject *freevars,*/
+        __pyx_empty_tuple, /*PyObject *cellvars,*/
+        py_srcfile,   /*PyObject *filename,*/
+        py_funcname,  /*PyObject *name,*/
+        py_line,
+        __pyx_empty_bytes  /*PyObject *lnotab*/
+    );
+    Py_DECREF(py_srcfile);
+    Py_DECREF(py_funcname);
+    return py_code;
+bad:
+    Py_XDECREF(py_srcfile);
+    Py_XDECREF(py_funcname);
+    return NULL;
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyCodeObject *py_code = 0;
+    PyFrameObject *py_frame = 0;
+    py_code = __pyx_find_code_object(c_line ? c_line : py_line);
+    if (!py_code) {
+        py_code = __Pyx_CreateCodeObjectForTraceback(
+            funcname, c_line, py_line, filename);
+        if (!py_code) goto bad;
+        __pyx_insert_code_object(c_line ? c_line : py_line, py_code);
+    }
+    py_frame = PyFrame_New(
+        PyThreadState_GET(), /*PyThreadState *tstate,*/
+        py_code,             /*PyCodeObject *code,*/
+        __pyx_d,      /*PyObject *globals,*/
+        0                    /*PyObject *locals*/
+    );
+    if (!py_frame) goto bad;
+    __Pyx_PyFrame_SetLineNumber(py_frame, py_line);
+    PyTraceBack_Here(py_frame);
+bad:
+    Py_XDECREF(py_code);
+    Py_XDECREF(py_frame);
+}
+
+#if PY_MAJOR_VERSION < 3
+static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) {
+    if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags);
+        if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags);
+    PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name);
+    return -1;
+}
+static void __Pyx_ReleaseBuffer(Py_buffer *view) {
+    PyObject *obj = view->obj;
+    if (!obj) return;
+    if (PyObject_CheckBuffer(obj)) {
+        PyBuffer_Release(view);
+        return;
+    }
+        if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) { __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); return; }
+    Py_DECREF(obj);
+    view->obj = NULL;
+}
+#endif
+
+
+              /* CIntToPy */
+              static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
+    const long neg_one = (long) -1, const_zero = (long) 0;
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(long) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(long) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(long) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(long),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntFromPyVerify */
+              #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
+    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0)
+#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\
+    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1)
+#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\
+    {\
+        func_type value = func_value;\
+        if (sizeof(target_type) < sizeof(func_type)) {\
+            if (unlikely(value != (func_type) (target_type) value)) {\
+                func_type zero = 0;\
+                if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\
+                    return (target_type) -1;\
+                if (is_unsigned && unlikely(value < zero))\
+                    goto raise_neg_overflow;\
+                else\
+                    goto raise_overflow;\
+            }\
+        }\
+        return (target_type) value;\
+    }
+
+/* CIntToPy */
+              static CYTHON_INLINE PyObject* __Pyx_PyInt_From_siz(siz value) {
+    const siz neg_one = (siz) -1, const_zero = (siz) 0;
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(siz) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(siz) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(siz) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(siz) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(siz) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(siz),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntToPy */
+              static CYTHON_INLINE PyObject* __Pyx_PyInt_From_Py_intptr_t(Py_intptr_t value) {
+    const Py_intptr_t neg_one = (Py_intptr_t) -1, const_zero = (Py_intptr_t) 0;
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(Py_intptr_t) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(Py_intptr_t) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(Py_intptr_t) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(Py_intptr_t) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(Py_intptr_t) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(Py_intptr_t),
+                                     little, !is_unsigned);
+    }
+}
+
+/* Declarations */
+              #if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
+      return ::std::complex< float >(x, y);
+    }
+  #else
+    static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
+      return x + y*(__pyx_t_float_complex)_Complex_I;
+    }
+  #endif
+#else
+    static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
+      __pyx_t_float_complex z;
+      z.real = x;
+      z.imag = y;
+      return z;
+    }
+#endif
+
+/* Arithmetic */
+              #if CYTHON_CCOMPLEX
+#else
+    static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+       return (a.real == b.real) && (a.imag == b.imag);
+    }
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        __pyx_t_float_complex z;
+        z.real = a.real + b.real;
+        z.imag = a.imag + b.imag;
+        return z;
+    }
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        __pyx_t_float_complex z;
+        z.real = a.real - b.real;
+        z.imag = a.imag - b.imag;
+        return z;
+    }
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        __pyx_t_float_complex z;
+        z.real = a.real * b.real - a.imag * b.imag;
+        z.imag = a.real * b.imag + a.imag * b.real;
+        return z;
+    }
+    #if 1
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        if (b.imag == 0) {
+            return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real);
+        } else if (fabsf(b.real) >= fabsf(b.imag)) {
+            if (b.real == 0 && b.imag == 0) {
+                return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag);
+            } else {
+                float r = b.imag / b.real;
+                float s = 1.0 / (b.real + b.imag * r);
+                return __pyx_t_float_complex_from_parts(
+                    (a.real + a.imag * r) * s, (a.imag - a.real * r) * s);
+            }
+        } else {
+            float r = b.real / b.imag;
+            float s = 1.0 / (b.imag + b.real * r);
+            return __pyx_t_float_complex_from_parts(
+                (a.real * r + a.imag) * s, (a.imag * r - a.real) * s);
+        }
+    }
+    #else
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        if (b.imag == 0) {
+            return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real);
+        } else {
+            float denom = b.real * b.real + b.imag * b.imag;
+            return __pyx_t_float_complex_from_parts(
+                (a.real * b.real + a.imag * b.imag) / denom,
+                (a.imag * b.real - a.real * b.imag) / denom);
+        }
+    }
+    #endif
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) {
+        __pyx_t_float_complex z;
+        z.real = -a.real;
+        z.imag = -a.imag;
+        return z;
+    }
+    static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) {
+       return (a.real == 0) && (a.imag == 0);
+    }
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) {
+        __pyx_t_float_complex z;
+        z.real =  a.real;
+        z.imag = -a.imag;
+        return z;
+    }
+    #if 1
+        static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) {
+          #if !defined(HAVE_HYPOT) || defined(_MSC_VER)
+            return sqrtf(z.real*z.real + z.imag*z.imag);
+          #else
+            return hypotf(z.real, z.imag);
+          #endif
+        }
+        static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+            __pyx_t_float_complex z;
+            float r, lnr, theta, z_r, z_theta;
+            if (b.imag == 0 && b.real == (int)b.real) {
+                if (b.real < 0) {
+                    float denom = a.real * a.real + a.imag * a.imag;
+                    a.real = a.real / denom;
+                    a.imag = -a.imag / denom;
+                    b.real = -b.real;
+                }
+                switch ((int)b.real) {
+                    case 0:
+                        z.real = 1;
+                        z.imag = 0;
+                        return z;
+                    case 1:
+                        return a;
+                    case 2:
+                        z = __Pyx_c_prod_float(a, a);
+                        return __Pyx_c_prod_float(a, a);
+                    case 3:
+                        z = __Pyx_c_prod_float(a, a);
+                        return __Pyx_c_prod_float(z, a);
+                    case 4:
+                        z = __Pyx_c_prod_float(a, a);
+                        return __Pyx_c_prod_float(z, z);
+                }
+            }
+            if (a.imag == 0) {
+                if (a.real == 0) {
+                    return a;
+                } else if (b.imag == 0) {
+                    z.real = powf(a.real, b.real);
+                    z.imag = 0;
+                    return z;
+                } else if (a.real > 0) {
+                    r = a.real;
+                    theta = 0;
+                } else {
+                    r = -a.real;
+                    theta = atan2f(0, -1);
+                }
+            } else {
+                r = __Pyx_c_abs_float(a);
+                theta = atan2f(a.imag, a.real);
+            }
+            lnr = logf(r);
+            z_r = expf(lnr * b.real - theta * b.imag);
+            z_theta = theta * b.real + lnr * b.imag;
+            z.real = z_r * cosf(z_theta);
+            z.imag = z_r * sinf(z_theta);
+            return z;
+        }
+    #endif
+#endif
+
+/* Declarations */
+              #if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
+      return ::std::complex< double >(x, y);
+    }
+  #else
+    static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
+      return x + y*(__pyx_t_double_complex)_Complex_I;
+    }
+  #endif
+#else
+    static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
+      __pyx_t_double_complex z;
+      z.real = x;
+      z.imag = y;
+      return z;
+    }
+#endif
+
+/* Arithmetic */
+              #if CYTHON_CCOMPLEX
+#else
+    static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+       return (a.real == b.real) && (a.imag == b.imag);
+    }
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        __pyx_t_double_complex z;
+        z.real = a.real + b.real;
+        z.imag = a.imag + b.imag;
+        return z;
+    }
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        __pyx_t_double_complex z;
+        z.real = a.real - b.real;
+        z.imag = a.imag - b.imag;
+        return z;
+    }
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        __pyx_t_double_complex z;
+        z.real = a.real * b.real - a.imag * b.imag;
+        z.imag = a.real * b.imag + a.imag * b.real;
+        return z;
+    }
+    #if 1
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        if (b.imag == 0) {
+            return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real);
+        } else if (fabs(b.real) >= fabs(b.imag)) {
+            if (b.real == 0 && b.imag == 0) {
+                return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag);
+            } else {
+                double r = b.imag / b.real;
+                double s = 1.0 / (b.real + b.imag * r);
+                return __pyx_t_double_complex_from_parts(
+                    (a.real + a.imag * r) * s, (a.imag - a.real * r) * s);
+            }
+        } else {
+            double r = b.real / b.imag;
+            double s = 1.0 / (b.imag + b.real * r);
+            return __pyx_t_double_complex_from_parts(
+                (a.real * r + a.imag) * s, (a.imag * r - a.real) * s);
+        }
+    }
+    #else
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        if (b.imag == 0) {
+            return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real);
+        } else {
+            double denom = b.real * b.real + b.imag * b.imag;
+            return __pyx_t_double_complex_from_parts(
+                (a.real * b.real + a.imag * b.imag) / denom,
+                (a.imag * b.real - a.real * b.imag) / denom);
+        }
+    }
+    #endif
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) {
+        __pyx_t_double_complex z;
+        z.real = -a.real;
+        z.imag = -a.imag;
+        return z;
+    }
+    static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) {
+       return (a.real == 0) && (a.imag == 0);
+    }
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) {
+        __pyx_t_double_complex z;
+        z.real =  a.real;
+        z.imag = -a.imag;
+        return z;
+    }
+    #if 1
+        static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) {
+          #if !defined(HAVE_HYPOT) || defined(_MSC_VER)
+            return sqrt(z.real*z.real + z.imag*z.imag);
+          #else
+            return hypot(z.real, z.imag);
+          #endif
+        }
+        static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+            __pyx_t_double_complex z;
+            double r, lnr, theta, z_r, z_theta;
+            if (b.imag == 0 && b.real == (int)b.real) {
+                if (b.real < 0) {
+                    double denom = a.real * a.real + a.imag * a.imag;
+                    a.real = a.real / denom;
+                    a.imag = -a.imag / denom;
+                    b.real = -b.real;
+                }
+                switch ((int)b.real) {
+                    case 0:
+                        z.real = 1;
+                        z.imag = 0;
+                        return z;
+                    case 1:
+                        return a;
+                    case 2:
+                        z = __Pyx_c_prod_double(a, a);
+                        return __Pyx_c_prod_double(a, a);
+                    case 3:
+                        z = __Pyx_c_prod_double(a, a);
+                        return __Pyx_c_prod_double(z, a);
+                    case 4:
+                        z = __Pyx_c_prod_double(a, a);
+                        return __Pyx_c_prod_double(z, z);
+                }
+            }
+            if (a.imag == 0) {
+                if (a.real == 0) {
+                    return a;
+                } else if (b.imag == 0) {
+                    z.real = pow(a.real, b.real);
+                    z.imag = 0;
+                    return z;
+                } else if (a.real > 0) {
+                    r = a.real;
+                    theta = 0;
+                } else {
+                    r = -a.real;
+                    theta = atan2(0, -1);
+                }
+            } else {
+                r = __Pyx_c_abs_double(a);
+                theta = atan2(a.imag, a.real);
+            }
+            lnr = log(r);
+            z_r = exp(lnr * b.real - theta * b.imag);
+            z_theta = theta * b.real + lnr * b.imag;
+            z.real = z_r * cos(z_theta);
+            z.imag = z_r * sin(z_theta);
+            return z;
+        }
+    #endif
+#endif
+
+/* CIntToPy */
+              static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
+    const int neg_one = (int) -1, const_zero = (int) 0;
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(int) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(int) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(int) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(int),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntToPy */
+              static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) {
+    const enum NPY_TYPES neg_one = (enum NPY_TYPES) -1, const_zero = (enum NPY_TYPES) 0;
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(enum NPY_TYPES) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(enum NPY_TYPES) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntFromPy */
+              static CYTHON_INLINE siz __Pyx_PyInt_As_siz(PyObject *x) {
+    const siz neg_one = (siz) -1, const_zero = (siz) 0;
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(siz) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(siz, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (siz) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (siz) 0;
+                case  1: __PYX_VERIFY_RETURN_INT(siz, digit, digits[0])
+                case 2:
+                    if (8 * sizeof(siz) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(siz, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(siz) >= 2 * PyLong_SHIFT) {
+                            return (siz) (((((siz)digits[1]) << PyLong_SHIFT) | (siz)digits[0]));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(siz) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(siz, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(siz) >= 3 * PyLong_SHIFT) {
+                            return (siz) (((((((siz)digits[2]) << PyLong_SHIFT) | (siz)digits[1]) << PyLong_SHIFT) | (siz)digits[0]));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(siz) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(siz, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(siz) >= 4 * PyLong_SHIFT) {
+                            return (siz) (((((((((siz)digits[3]) << PyLong_SHIFT) | (siz)digits[2]) << PyLong_SHIFT) | (siz)digits[1]) << PyLong_SHIFT) | (siz)digits[0]));
+                        }
+                    }
+                    break;
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (siz) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if (sizeof(siz) <= sizeof(unsigned long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(siz, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(siz) <= sizeof(unsigned PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(siz, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (siz) 0;
+                case -1: __PYX_VERIFY_RETURN_INT(siz, sdigit, (sdigit) (-(sdigit)digits[0]))
+                case  1: __PYX_VERIFY_RETURN_INT(siz,  digit, +digits[0])
+                case -2:
+                    if (8 * sizeof(siz) - 1 > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(siz, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(siz) - 1 > 2 * PyLong_SHIFT) {
+                            return (siz) (((siz)-1)*(((((siz)digits[1]) << PyLong_SHIFT) | (siz)digits[0])));
+                        }
+                    }
+                    break;
+                case 2:
+                    if (8 * sizeof(siz) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(siz, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(siz) - 1 > 2 * PyLong_SHIFT) {
+                            return (siz) ((((((siz)digits[1]) << PyLong_SHIFT) | (siz)digits[0])));
+                        }
+                    }
+                    break;
+                case -3:
+                    if (8 * sizeof(siz) - 1 > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(siz, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(siz) - 1 > 3 * PyLong_SHIFT) {
+                            return (siz) (((siz)-1)*(((((((siz)digits[2]) << PyLong_SHIFT) | (siz)digits[1]) << PyLong_SHIFT) | (siz)digits[0])));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(siz) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(siz, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(siz) - 1 > 3 * PyLong_SHIFT) {
+                            return (siz) ((((((((siz)digits[2]) << PyLong_SHIFT) | (siz)digits[1]) << PyLong_SHIFT) | (siz)digits[0])));
+                        }
+                    }
+                    break;
+                case -4:
+                    if (8 * sizeof(siz) - 1 > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(siz, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(siz) - 1 > 4 * PyLong_SHIFT) {
+                            return (siz) (((siz)-1)*(((((((((siz)digits[3]) << PyLong_SHIFT) | (siz)digits[2]) << PyLong_SHIFT) | (siz)digits[1]) << PyLong_SHIFT) | (siz)digits[0])));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(siz) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(siz, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(siz) - 1 > 4 * PyLong_SHIFT) {
+                            return (siz) ((((((((((siz)digits[3]) << PyLong_SHIFT) | (siz)digits[2]) << PyLong_SHIFT) | (siz)digits[1]) << PyLong_SHIFT) | (siz)digits[0])));
+                        }
+                    }
+                    break;
+            }
+#endif
+            if (sizeof(siz) <= sizeof(long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(siz, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(siz) <= sizeof(PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(siz, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+            PyErr_SetString(PyExc_RuntimeError,
+                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+            siz val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+ #endif
+            if (likely(v)) {
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                int ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                              bytes, sizeof(val),
+                                              is_little, !is_unsigned);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            return (siz) -1;
+        }
+    } else {
+        siz val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (siz) -1;
+        val = __Pyx_PyInt_As_siz(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to siz");
+    return (siz) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to siz");
+    return (siz) -1;
+}
+
+/* CIntFromPy */
+              static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
+    const size_t neg_one = (size_t) -1, const_zero = (size_t) 0;
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(size_t) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (size_t) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (size_t) 0;
+                case  1: __PYX_VERIFY_RETURN_INT(size_t, digit, digits[0])
+                case 2:
+                    if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(size_t) >= 2 * PyLong_SHIFT) {
+                            return (size_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(size_t) >= 3 * PyLong_SHIFT) {
+                            return (size_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(size_t) >= 4 * PyLong_SHIFT) {
+                            return (size_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+                        }
+                    }
+                    break;
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (size_t) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if (sizeof(size_t) <= sizeof(unsigned long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (size_t) 0;
+                case -1: __PYX_VERIFY_RETURN_INT(size_t, sdigit, (sdigit) (-(sdigit)digits[0]))
+                case  1: __PYX_VERIFY_RETURN_INT(size_t,  digit, +digits[0])
+                case -2:
+                    if (8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
+                            return (size_t) (((size_t)-1)*(((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
+                        }
+                    }
+                    break;
+                case 2:
+                    if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
+                            return (size_t) ((((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
+                        }
+                    }
+                    break;
+                case -3:
+                    if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
+                            return (size_t) (((size_t)-1)*(((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
+                            return (size_t) ((((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
+                        }
+                    }
+                    break;
+                case -4:
+                    if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
+                            return (size_t) (((size_t)-1)*(((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
+                            return (size_t) ((((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
+                        }
+                    }
+                    break;
+            }
+#endif
+            if (sizeof(size_t) <= sizeof(long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(size_t) <= sizeof(PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+            PyErr_SetString(PyExc_RuntimeError,
+                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+            size_t val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+ #endif
+            if (likely(v)) {
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                int ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                              bytes, sizeof(val),
+                                              is_little, !is_unsigned);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            return (size_t) -1;
+        }
+    } else {
+        size_t val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (size_t) -1;
+        val = __Pyx_PyInt_As_size_t(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to size_t");
+    return (size_t) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to size_t");
+    return (size_t) -1;
+}
+
+/* CIntFromPy */
+              static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
+    const int neg_one = (int) -1, const_zero = (int) 0;
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(int) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (int) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (int) 0;
+                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
+                case 2:
+                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
+                            return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
+                            return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
+                            return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                        }
+                    }
+                    break;
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (int) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if (sizeof(int) <= sizeof(unsigned long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (int) 0;
+                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
+                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
+                case -2:
+                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                            return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case 2:
+                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                            return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case -3:
+                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                            return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                            return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case -4:
+                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                            return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                            return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+            }
+#endif
+            if (sizeof(int) <= sizeof(long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+            PyErr_SetString(PyExc_RuntimeError,
+                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+            int val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+ #endif
+            if (likely(v)) {
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                int ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                              bytes, sizeof(val),
+                                              is_little, !is_unsigned);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            return (int) -1;
+        }
+    } else {
+        int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (int) -1;
+        val = __Pyx_PyInt_As_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to int");
+    return (int) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to int");
+    return (int) -1;
+}
+
+/* CIntFromPy */
+              static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
+    const long neg_one = (long) -1, const_zero = (long) 0;
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(long) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (long) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (long) 0;
+                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
+                case 2:
+                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
+                            return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
+                            return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
+                            return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                        }
+                    }
+                    break;
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (long) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if (sizeof(long) <= sizeof(unsigned long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (long) 0;
+                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
+                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
+                case -2:
+                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                            return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case 2:
+                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                            return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case -3:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                            return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                            return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case -4:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                            return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                            return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+            }
+#endif
+            if (sizeof(long) <= sizeof(long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+            PyErr_SetString(PyExc_RuntimeError,
+                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+            long val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+ #endif
+            if (likely(v)) {
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                int ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                              bytes, sizeof(val),
+                                              is_little, !is_unsigned);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            return (long) -1;
+        }
+    } else {
+        long val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (long) -1;
+        val = __Pyx_PyInt_As_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to long");
+    return (long) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to long");
+    return (long) -1;
+}
+
+/* CheckBinaryVersion */
+              static int __Pyx_check_binary_version(void) {
+    char ctversion[4], rtversion[4];
+    PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
+    PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion());
+    if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) {
+        char message[200];
+        PyOS_snprintf(message, sizeof(message),
+                      "compiletime version %s of module '%.100s' "
+                      "does not match runtime version %s",
+                      ctversion, __Pyx_MODULE_NAME, rtversion);
+        return PyErr_WarnEx(NULL, message, 1);
+    }
+    return 0;
+}
+
+/* ModuleImport */
+              #ifndef __PYX_HAVE_RT_ImportModule
+#define __PYX_HAVE_RT_ImportModule
+static PyObject *__Pyx_ImportModule(const char *name) {
+    PyObject *py_name = 0;
+    PyObject *py_module = 0;
+    py_name = __Pyx_PyIdentifier_FromString(name);
+    if (!py_name)
+        goto bad;
+    py_module = PyImport_Import(py_name);
+    Py_DECREF(py_name);
+    return py_module;
+bad:
+    Py_XDECREF(py_name);
+    return 0;
+}
+#endif
+
+/* TypeImport */
+              #ifndef __PYX_HAVE_RT_ImportType
+#define __PYX_HAVE_RT_ImportType
+static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name,
+    size_t size, int strict)
+{
+    PyObject *py_module = 0;
+    PyObject *result = 0;
+    PyObject *py_name = 0;
+    char warning[200];
+    Py_ssize_t basicsize;
+#ifdef Py_LIMITED_API
+    PyObject *py_basicsize;
+#endif
+    py_module = __Pyx_ImportModule(module_name);
+    if (!py_module)
+        goto bad;
+    py_name = __Pyx_PyIdentifier_FromString(class_name);
+    if (!py_name)
+        goto bad;
+    result = PyObject_GetAttr(py_module, py_name);
+    Py_DECREF(py_name);
+    py_name = 0;
+    Py_DECREF(py_module);
+    py_module = 0;
+    if (!result)
+        goto bad;
+    if (!PyType_Check(result)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s.%.200s is not a type object",
+            module_name, class_name);
+        goto bad;
+    }
+#ifndef Py_LIMITED_API
+    basicsize = ((PyTypeObject *)result)->tp_basicsize;
+#else
+    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
+    if (!py_basicsize)
+        goto bad;
+    basicsize = PyLong_AsSsize_t(py_basicsize);
+    Py_DECREF(py_basicsize);
+    py_basicsize = 0;
+    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
+#endif
+    if (!strict && (size_t)basicsize > size) {
+        PyOS_snprintf(warning, sizeof(warning),
+            "%s.%s size changed, may indicate binary incompatibility. Expected %zd, got %zd",
+            module_name, class_name, basicsize, size);
+        if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
+    }
+    else if ((size_t)basicsize != size) {
+        PyErr_Format(PyExc_ValueError,
+            "%.200s.%.200s has the wrong size, try recompiling. Expected %zd, got %zd",
+            module_name, class_name, basicsize, size);
+        goto bad;
+    }
+    return (PyTypeObject *)result;
+bad:
+    Py_XDECREF(py_module);
+    Py_XDECREF(result);
+    return NULL;
+}
+#endif
+
+/* InitStrings */
+              static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
+    while (t->p) {
+        #if PY_MAJOR_VERSION < 3
+        if (t->is_unicode) {
+            *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
+        } else if (t->intern) {
+            *t->p = PyString_InternFromString(t->s);
+        } else {
+            *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
+        }
+        #else
+        if (t->is_unicode | t->is_str) {
+            if (t->intern) {
+                *t->p = PyUnicode_InternFromString(t->s);
+            } else if (t->encoding) {
+                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
+            } else {
+                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
+            }
+        } else {
+            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
+        }
+        #endif
+        if (!*t->p)
+            return -1;
+        ++t;
+    }
+    return 0;
+}
+
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
+}
+static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) {
+    Py_ssize_t ignore;
+    return __Pyx_PyObject_AsStringAndSize(o, &ignore);
+}
+static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
+    if (
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+            __Pyx_sys_getdefaultencoding_not_ascii &&
+#endif
+            PyUnicode_Check(o)) {
+#if PY_VERSION_HEX < 0x03030000
+        char* defenc_c;
+        PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL);
+        if (!defenc) return NULL;
+        defenc_c = PyBytes_AS_STRING(defenc);
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+        {
+            char* end = defenc_c + PyBytes_GET_SIZE(defenc);
+            char* c;
+            for (c = defenc_c; c < end; c++) {
+                if ((unsigned char) (*c) >= 128) {
+                    PyUnicode_AsASCIIString(o);
+                    return NULL;
+                }
+            }
+        }
+#endif
+        *length = PyBytes_GET_SIZE(defenc);
+        return defenc_c;
+#else
+        if (__Pyx_PyUnicode_READY(o) == -1) return NULL;
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+        if (PyUnicode_IS_ASCII(o)) {
+            *length = PyUnicode_GET_LENGTH(o);
+            return PyUnicode_AsUTF8(o);
+        } else {
+            PyUnicode_AsASCIIString(o);
+            return NULL;
+        }
+#else
+        return PyUnicode_AsUTF8AndSize(o, length);
+#endif
+#endif
+    } else
+#endif
+#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+    if (PyByteArray_Check(o)) {
+        *length = PyByteArray_GET_SIZE(o);
+        return PyByteArray_AS_STRING(o);
+    } else
+#endif
+    {
+        char* result;
+        int r = PyBytes_AsStringAndSize(o, &result, length);
+        if (unlikely(r < 0)) {
+            return NULL;
+        } else {
+            return result;
+        }
+    }
+}
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
+   int is_true = x == Py_True;
+   if (is_true | (x == Py_False) | (x == Py_None)) return is_true;
+   else return PyObject_IsTrue(x);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) {
+#if CYTHON_USE_TYPE_SLOTS
+  PyNumberMethods *m;
+#endif
+  const char *name = NULL;
+  PyObject *res = NULL;
+#if PY_MAJOR_VERSION < 3
+  if (PyInt_Check(x) || PyLong_Check(x))
+#else
+  if (PyLong_Check(x))
+#endif
+    return __Pyx_NewRef(x);
+#if CYTHON_USE_TYPE_SLOTS
+  m = Py_TYPE(x)->tp_as_number;
+  #if PY_MAJOR_VERSION < 3
+  if (m && m->nb_int) {
+    name = "int";
+    res = PyNumber_Int(x);
+  }
+  else if (m && m->nb_long) {
+    name = "long";
+    res = PyNumber_Long(x);
+  }
+  #else
+  if (m && m->nb_int) {
+    name = "int";
+    res = PyNumber_Long(x);
+  }
+  #endif
+#else
+  res = PyNumber_Int(x);
+#endif
+  if (res) {
+#if PY_MAJOR_VERSION < 3
+    if (!PyInt_Check(res) && !PyLong_Check(res)) {
+#else
+    if (!PyLong_Check(res)) {
+#endif
+      PyErr_Format(PyExc_TypeError,
+                   "__%.4s__ returned non-%.4s (type %.200s)",
+                   name, name, Py_TYPE(res)->tp_name);
+      Py_DECREF(res);
+      return NULL;
+    }
+  }
+  else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_TypeError,
+                    "an integer is required");
+  }
+  return res;
+}
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
+  Py_ssize_t ival;
+  PyObject *x;
+#if PY_MAJOR_VERSION < 3
+  if (likely(PyInt_CheckExact(b))) {
+    if (sizeof(Py_ssize_t) >= sizeof(long))
+        return PyInt_AS_LONG(b);
+    else
+        return PyInt_AsSsize_t(x);
+  }
+#endif
+  if (likely(PyLong_CheckExact(b))) {
+    #if CYTHON_USE_PYLONG_INTERNALS
+    const digit* digits = ((PyLongObject*)b)->ob_digit;
+    const Py_ssize_t size = Py_SIZE(b);
+    if (likely(__Pyx_sst_abs(size) <= 1)) {
+        ival = likely(size) ? digits[0] : 0;
+        if (size == -1) ival = -ival;
+        return ival;
+    } else {
+      switch (size) {
+         case 2:
+           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -2:
+           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case 3:
+           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -3:
+           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case 4:
+           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -4:
+           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+      }
+    }
+    #endif
+    return PyLong_AsSsize_t(b);
+  }
+  x = PyNumber_Index(b);
+  if (!x) return -1;
+  ival = PyInt_AsSsize_t(x);
+  Py_DECREF(x);
+  return ival;
+}
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
+    return PyInt_FromSize_t(ival);
+}
+
+
+#endif /* Py_PYTHON_H */
diff --git a/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/pycocotools/_mask.pyx b/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/pycocotools/_mask.pyx
new file mode 100755
index 0000000..d065837
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/pycocotools/_mask.pyx
@@ -0,0 +1,308 @@
+# distutils: language = c
+# distutils: sources = ../common/maskApi.c
+
+#**************************************************************************
+# Microsoft COCO Toolbox.      version 2.0
+# Data, paper, and tutorials available at:  http://mscoco.org/
+# Code written by Piotr Dollar and Tsung-Yi Lin, 2015.
+# Licensed under the Simplified BSD License [see coco/license.txt]
+#**************************************************************************
+
+__author__ = 'tsungyi'
+
+import sys
+PYTHON_VERSION = sys.version_info[0]
+
+# import both Python-level and C-level symbols of Numpy
+# the API uses Numpy to interface C and Python
+import numpy as np
+cimport numpy as np
+from libc.stdlib cimport malloc, free
+
+# intialized Numpy. must do.
+np.import_array()
+
+# import numpy C function
+# we use PyArray_ENABLEFLAGS to make Numpy ndarray responsible to memoery management
+cdef extern from "numpy/arrayobject.h":
+    void PyArray_ENABLEFLAGS(np.ndarray arr, int flags)
+
+# Declare the prototype of the C functions in MaskApi.h
+cdef extern from "maskApi.h":
+    ctypedef unsigned int uint
+    ctypedef unsigned long siz
+    ctypedef unsigned char byte
+    ctypedef double* BB
+    ctypedef struct RLE:
+        siz h,
+        siz w,
+        siz m,
+        uint* cnts,
+    void rlesInit( RLE **R, siz n )
+    void rleEncode( RLE *R, const byte *M, siz h, siz w, siz n )
+    void rleDecode( const RLE *R, byte *mask, siz n )
+    void rleMerge( const RLE *R, RLE *M, siz n, int intersect )
+    void rleArea( const RLE *R, siz n, uint *a )
+    void rleIou( RLE *dt, RLE *gt, siz m, siz n, byte *iscrowd, double *o )
+    void bbIou( BB dt, BB gt, siz m, siz n, byte *iscrowd, double *o )
+    void rleToBbox( const RLE *R, BB bb, siz n )
+    void rleFrBbox( RLE *R, const BB bb, siz h, siz w, siz n )
+    void rleFrPoly( RLE *R, const double *xy, siz k, siz h, siz w )
+    char* rleToString( const RLE *R )
+    void rleFrString( RLE *R, char *s, siz h, siz w )
+
+# python class to wrap RLE array in C
+# the class handles the memory allocation and deallocation
+cdef class RLEs:
+    cdef RLE *_R
+    cdef siz _n
+
+    def __cinit__(self, siz n =0):
+        rlesInit(&self._R, n)
+        self._n = n
+
+    # free the RLE array here
+    def __dealloc__(self):
+        if self._R is not NULL:
+            for i in range(self._n):
+                free(self._R[i].cnts)
+            free(self._R)
+    def __getattr__(self, key):
+        if key == 'n':
+            return self._n
+        raise AttributeError(key)
+
+# python class to wrap Mask array in C
+# the class handles the memory allocation and deallocation
+cdef class Masks:
+    cdef byte *_mask
+    cdef siz _h
+    cdef siz _w
+    cdef siz _n
+
+    def __cinit__(self, h, w, n):
+        self._mask = <byte*> malloc(h*w*n* sizeof(byte))
+        self._h = h
+        self._w = w
+        self._n = n
+    # def __dealloc__(self):
+        # the memory management of _mask has been passed to np.ndarray
+        # it doesn't need to be freed here
+
+    # called when passing into np.array() and return an np.ndarray in column-major order
+    def __array__(self):
+        cdef np.npy_intp shape[1]
+        shape[0] = <np.npy_intp> self._h*self._w*self._n
+        # Create a 1D array, and reshape it to fortran/Matlab column-major array
+        ndarray = np.PyArray_SimpleNewFromData(1, shape, np.NPY_UINT8, self._mask).reshape((self._h, self._w, self._n), order='F')
+        # The _mask allocated by Masks is now handled by ndarray
+        PyArray_ENABLEFLAGS(ndarray, np.NPY_OWNDATA)
+        return ndarray
+
+# internal conversion from Python RLEs object to compressed RLE format
+def _toString(RLEs Rs):
+    cdef siz n = Rs.n
+    cdef bytes py_string
+    cdef char* c_string
+    objs = []
+    for i in range(n):
+        c_string = rleToString( <RLE*> &Rs._R[i] )
+        py_string = c_string
+        objs.append({
+            'size': [Rs._R[i].h, Rs._R[i].w],
+            'counts': py_string
+        })
+        free(c_string)
+    return objs
+
+# internal conversion from compressed RLE format to Python RLEs object
+def _frString(rleObjs):
+    cdef siz n = len(rleObjs)
+    Rs = RLEs(n)
+    cdef bytes py_string
+    cdef char* c_string
+    for i, obj in enumerate(rleObjs):
+        if PYTHON_VERSION == 2:
+            py_string = str(obj['counts']).encode('utf8')
+        elif PYTHON_VERSION == 3:
+            py_string = str.encode(obj['counts']) if type(obj['counts']) == str else obj['counts']
+        else:
+            raise Exception('Python version must be 2 or 3')
+        c_string = py_string
+        rleFrString( <RLE*> &Rs._R[i], <char*> c_string, obj['size'][0], obj['size'][1] )
+    return Rs
+
+# encode mask to RLEs objects
+# list of RLE string can be generated by RLEs member function
+def encode(np.ndarray[np.uint8_t, ndim=3, mode='fortran'] mask):
+    h, w, n = mask.shape[0], mask.shape[1], mask.shape[2]
+    cdef RLEs Rs = RLEs(n)
+    rleEncode(Rs._R,<byte*>mask.data,h,w,n)
+    objs = _toString(Rs)
+    return objs
+
+# decode mask from compressed list of RLE string or RLEs object
+def decode(rleObjs):
+    cdef RLEs Rs = _frString(rleObjs)
+    h, w, n = Rs._R[0].h, Rs._R[0].w, Rs._n
+    masks = Masks(h, w, n)
+    rleDecode(<RLE*>Rs._R, masks._mask, n);
+    return np.array(masks)
+
+def merge(rleObjs, intersect=0):
+    cdef RLEs Rs = _frString(rleObjs)
+    cdef RLEs R = RLEs(1)
+    rleMerge(<RLE*>Rs._R, <RLE*> R._R, <siz> Rs._n, intersect)
+    obj = _toString(R)[0]
+    return obj
+
+def area(rleObjs):
+    cdef RLEs Rs = _frString(rleObjs)
+    cdef uint* _a = <uint*> malloc(Rs._n* sizeof(uint))
+    rleArea(Rs._R, Rs._n, _a)
+    cdef np.npy_intp shape[1]
+    shape[0] = <np.npy_intp> Rs._n
+    a = np.array((Rs._n, ), dtype=np.uint8)
+    a = np.PyArray_SimpleNewFromData(1, shape, np.NPY_UINT32, _a)
+    PyArray_ENABLEFLAGS(a, np.NPY_OWNDATA)
+    return a
+
+# iou computation. support function overload (RLEs-RLEs and bbox-bbox).
+def iou( dt, gt, pyiscrowd ):
+    def _preproc(objs):
+        if len(objs) == 0:
+            return objs
+        if type(objs) == np.ndarray:
+            if len(objs.shape) == 1:
+                objs = objs.reshape((objs[0], 1))
+            # check if it's Nx4 bbox
+            if not len(objs.shape) == 2 or not objs.shape[1] == 4:
+                raise Exception('numpy ndarray input is only for *bounding boxes* and should have Nx4 dimension')
+            objs = objs.astype(np.double)
+        elif type(objs) == list:
+            # check if list is in box format and convert it to np.ndarray
+            isbox = np.all(np.array([(len(obj)==4) and ((type(obj)==list) or (type(obj)==np.ndarray)) for obj in objs]))
+            isrle = np.all(np.array([type(obj) == dict for obj in objs]))
+            if isbox:
+                objs = np.array(objs, dtype=np.double)
+                if len(objs.shape) == 1:
+                    objs = objs.reshape((1,objs.shape[0]))
+            elif isrle:
+                objs = _frString(objs)
+            else:
+                raise Exception('list input can be bounding box (Nx4) or RLEs ([RLE])')
+        else:
+            raise Exception('unrecognized type.  The following type: RLEs (rle), np.ndarray (box), and list (box) are supported.')
+        return objs
+    def _rleIou(RLEs dt, RLEs gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t,  ndim=1] _iou):
+        rleIou( <RLE*> dt._R, <RLE*> gt._R, m, n, <byte*> iscrowd.data, <double*> _iou.data )
+    def _bbIou(np.ndarray[np.double_t, ndim=2] dt, np.ndarray[np.double_t, ndim=2] gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t, ndim=1] _iou):
+        bbIou( <BB> dt.data, <BB> gt.data, m, n, <byte*> iscrowd.data, <double*>_iou.data )
+    def _len(obj):
+        cdef siz N = 0
+        if type(obj) == RLEs:
+            N = obj.n
+        elif len(obj)==0:
+            pass
+        elif type(obj) == np.ndarray:
+            N = obj.shape[0]
+        return N
+    # convert iscrowd to numpy array
+    cdef np.ndarray[np.uint8_t, ndim=1] iscrowd = np.array(pyiscrowd, dtype=np.uint8)
+    # simple type checking
+    cdef siz m, n
+    dt = _preproc(dt)
+    gt = _preproc(gt)
+    m = _len(dt)
+    n = _len(gt)
+    if m == 0 or n == 0:
+        return []
+    if not type(dt) == type(gt):
+        raise Exception('The dt and gt should have the same data type, either RLEs, list or np.ndarray')
+
+    # define local variables
+    cdef double* _iou = <double*> 0
+    cdef np.npy_intp shape[1]
+    # check type and assign iou function
+    if type(dt) == RLEs:
+        _iouFun = _rleIou
+    elif type(dt) == np.ndarray:
+        _iouFun = _bbIou
+    else:
+        raise Exception('input data type not allowed.')
+    _iou = <double*> malloc(m*n* sizeof(double))
+    iou = np.zeros((m*n, ), dtype=np.double)
+    shape[0] = <np.npy_intp> m*n
+    iou = np.PyArray_SimpleNewFromData(1, shape, np.NPY_DOUBLE, _iou)
+    PyArray_ENABLEFLAGS(iou, np.NPY_OWNDATA)
+    _iouFun(dt, gt, iscrowd, m, n, iou)
+    return iou.reshape((m,n), order='F')
+
+def toBbox( rleObjs ):
+    cdef RLEs Rs = _frString(rleObjs)
+    cdef siz n = Rs.n
+    cdef BB _bb = <BB> malloc(4*n* sizeof(double))
+    rleToBbox( <const RLE*> Rs._R, _bb, n )
+    cdef np.npy_intp shape[1]
+    shape[0] = <np.npy_intp> 4*n
+    bb = np.array((1,4*n), dtype=np.double)
+    bb = np.PyArray_SimpleNewFromData(1, shape, np.NPY_DOUBLE, _bb).reshape((n, 4))
+    PyArray_ENABLEFLAGS(bb, np.NPY_OWNDATA)
+    return bb
+
+def frBbox(np.ndarray[np.double_t, ndim=2] bb, siz h, siz w ):
+    cdef siz n = bb.shape[0]
+    Rs = RLEs(n)
+    rleFrBbox( <RLE*> Rs._R, <const BB> bb.data, h, w, n )
+    objs = _toString(Rs)
+    return objs
+
+def frPoly( poly, siz h, siz w ):
+    cdef np.ndarray[np.double_t, ndim=1] np_poly
+    n = len(poly)
+    Rs = RLEs(n)
+    for i, p in enumerate(poly):
+        np_poly = np.array(p, dtype=np.double, order='F')
+        rleFrPoly( <RLE*>&Rs._R[i], <const double*> np_poly.data, int(len(p)/2), h, w )
+    objs = _toString(Rs)
+    return objs
+
+def frUncompressedRLE(ucRles, siz h, siz w):
+    cdef np.ndarray[np.uint32_t, ndim=1] cnts
+    cdef RLE R
+    cdef uint *data
+    n = len(ucRles)
+    objs = []
+    for i in range(n):
+        Rs = RLEs(1)
+        cnts = np.array(ucRles[i]['counts'], dtype=np.uint32)
+        # time for malloc can be saved here but it's fine
+        data = <uint*> malloc(len(cnts)* sizeof(uint))
+        for j in range(len(cnts)):
+            data[j] = <uint> cnts[j]
+        R = RLE(ucRles[i]['size'][0], ucRles[i]['size'][1], len(cnts), <uint*> data)
+        Rs._R[0] = R
+        objs.append(_toString(Rs)[0])
+    return objs
+
+def frPyObjects(pyobj, h, w):
+    # encode rle from a list of python objects
+    if type(pyobj) == np.ndarray:
+        objs = frBbox(pyobj, h, w)
+    elif type(pyobj) == list and len(pyobj[0]) == 4:
+        objs = frBbox(pyobj, h, w)
+    elif type(pyobj) == list and len(pyobj[0]) > 4:
+        objs = frPoly(pyobj, h, w)
+    elif type(pyobj) == list and type(pyobj[0]) == dict \
+        and 'counts' in pyobj[0] and 'size' in pyobj[0]:
+        objs = frUncompressedRLE(pyobj, h, w)
+    # encode rle from single python object
+    elif type(pyobj) == list and len(pyobj) == 4:
+        objs = frBbox([pyobj], h, w)[0]
+    elif type(pyobj) == list and len(pyobj) > 4:
+        objs = frPoly([pyobj], h, w)[0]
+    elif type(pyobj) == dict and 'counts' in pyobj and 'size' in pyobj:
+        objs = frUncompressedRLE([pyobj], h, w)[0]
+    else:
+        raise Exception('input type is not supported.')
+    return objs
diff --git a/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/pycocotools/coco.py b/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/pycocotools/coco.py
new file mode 100755
index 0000000..dc9972b
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/pycocotools/coco.py
@@ -0,0 +1,433 @@
+__author__ = 'tylin'
+__version__ = '2.0'
+# Interface for accessing the Microsoft COCO dataset.
+
+# Microsoft COCO is a large image dataset designed for object detection,
+# segmentation, and caption generation. pycocotools is a Python API that
+# assists in loading, parsing and visualizing the annotations in COCO.
+# Please visit http://mscoco.org/ for more information on COCO, including
+# for the data, paper, and tutorials. The exact format of the annotations
+# is also described on the COCO website. For example usage of the pycocotools
+# please see pycocotools_demo.ipynb. In addition to this API, please download both
+# the COCO images and annotations in order to run the demo.
+
+# An alternative to using the API is to load the annotations directly
+# into Python dictionary
+# Using the API provides additional utility functions. Note that this API
+# supports both *instance* and *caption* annotations. In the case of
+# captions not all functions are defined (e.g. categories are undefined).
+
+# The following API functions are defined:
+#  COCO       - COCO api class that loads COCO annotation file and prepare data structures.
+#  decodeMask - Decode binary mask M encoded via run-length encoding.
+#  encodeMask - Encode binary mask M using run-length encoding.
+#  getAnnIds  - Get ann ids that satisfy given filter conditions.
+#  getCatIds  - Get cat ids that satisfy given filter conditions.
+#  getImgIds  - Get img ids that satisfy given filter conditions.
+#  loadAnns   - Load anns with the specified ids.
+#  loadCats   - Load cats with the specified ids.
+#  loadImgs   - Load imgs with the specified ids.
+#  annToMask  - Convert segmentation in an annotation to binary mask.
+#  showAnns   - Display the specified annotations.
+#  loadRes    - Load algorithm results and create API for accessing them.
+#  download   - Download COCO images from mscoco.org server.
+# Throughout the API "ann"=annotation, "cat"=category, and "img"=image.
+# Help on each functions can be accessed by: "help COCO>function".
+
+# See also COCO>decodeMask,
+# COCO>encodeMask, COCO>getAnnIds, COCO>getCatIds,
+# COCO>getImgIds, COCO>loadAnns, COCO>loadCats,
+# COCO>loadImgs, COCO>annToMask, COCO>showAnns
+
+# Microsoft COCO Toolbox.      version 2.0
+# Data, paper, and tutorials available at:  http://mscoco.org/
+# Code written by Piotr Dollar and Tsung-Yi Lin, 2014.
+# Licensed under the Simplified BSD License [see bsd.txt]
+
+import json
+import time
+import matplotlib.pyplot as plt
+from matplotlib.collections import PatchCollection
+from matplotlib.patches import Polygon
+import numpy as np
+import copy
+import itertools
+from . import mask as maskUtils
+import os
+from collections import defaultdict
+import sys
+PYTHON_VERSION = sys.version_info[0]
+if PYTHON_VERSION == 2:
+    from urllib import urlretrieve
+elif PYTHON_VERSION == 3:
+    from urllib.request import urlretrieve
+
+
+def _isArrayLike(obj):
+    return hasattr(obj, '__iter__') and hasattr(obj, '__len__')
+
+
+class COCO:
+    def __init__(self, annotation_file=None):
+        """
+        Constructor of Microsoft COCO helper class for reading and visualizing annotations.
+        :param annotation_file (str): location of annotation file
+        :param image_folder (str): location to the folder that hosts images.
+        :return:
+        """
+        # load dataset
+        self.dataset,self.anns,self.cats,self.imgs = dict(),dict(),dict(),dict()
+        self.imgToAnns, self.catToImgs = defaultdict(list), defaultdict(list)
+        if not annotation_file == None:
+            print('loading annotations into memory...')
+            tic = time.time()
+            dataset = json.load(open(annotation_file, 'r'))
+            assert type(dataset)==dict, 'annotation file format {} not supported'.format(type(dataset))
+            print('Done (t={:0.2f}s)'.format(time.time()- tic))
+            self.dataset = dataset
+            self.createIndex()
+
+    def createIndex(self):
+        # create index
+        print('creating index...')
+        anns, cats, imgs = {}, {}, {}
+        imgToAnns,catToImgs = defaultdict(list),defaultdict(list)
+        if 'annotations' in self.dataset:
+            for ann in self.dataset['annotations']:
+                imgToAnns[ann['image_id']].append(ann)
+                anns[ann['id']] = ann
+
+        if 'images' in self.dataset:
+            for img in self.dataset['images']:
+                imgs[img['id']] = img
+
+        if 'categories' in self.dataset:
+            for cat in self.dataset['categories']:
+                cats[cat['id']] = cat
+
+        if 'annotations' in self.dataset and 'categories' in self.dataset:
+            for ann in self.dataset['annotations']:
+                catToImgs[ann['category_id']].append(ann['image_id'])
+
+        print('index created!')
+
+        # create class members
+        self.anns = anns
+        self.imgToAnns = imgToAnns
+        self.catToImgs = catToImgs
+        self.imgs = imgs
+        self.cats = cats
+
+    def info(self):
+        """
+        Print information about the annotation file.
+        :return:
+        """
+        for key, value in self.dataset['info'].items():
+            print('{}: {}'.format(key, value))
+
+    def getAnnIds(self, imgIds=[], catIds=[], areaRng=[], iscrowd=None):
+        """
+        Get ann ids that satisfy given filter conditions. default skips that filter
+        :param imgIds  (int array)     : get anns for given imgs
+               catIds  (int array)     : get anns for given cats
+               areaRng (float array)   : get anns for given area range (e.g. [0 inf])
+               iscrowd (boolean)       : get anns for given crowd label (False or True)
+        :return: ids (int array)       : integer array of ann ids
+        """
+        imgIds = imgIds if _isArrayLike(imgIds) else [imgIds]
+        catIds = catIds if _isArrayLike(catIds) else [catIds]
+
+        if len(imgIds) == len(catIds) == len(areaRng) == 0:
+            anns = self.dataset['annotations']
+        else:
+            if not len(imgIds) == 0:
+                lists = [self.imgToAnns[imgId] for imgId in imgIds if imgId in self.imgToAnns]
+                anns = list(itertools.chain.from_iterable(lists))
+            else:
+                anns = self.dataset['annotations']
+            anns = anns if len(catIds)  == 0 else [ann for ann in anns if ann['category_id'] in catIds]
+            anns = anns if len(areaRng) == 0 else [ann for ann in anns if ann['area'] > areaRng[0] and ann['area'] < areaRng[1]]
+        if not iscrowd == None:
+            ids = [ann['id'] for ann in anns if ann['iscrowd'] == iscrowd]
+        else:
+            ids = [ann['id'] for ann in anns]
+        return ids
+
+    def getCatIds(self, catNms=[], supNms=[], catIds=[]):
+        """
+        filtering parameters. default skips that filter.
+        :param catNms (str array)  : get cats for given cat names
+        :param supNms (str array)  : get cats for given supercategory names
+        :param catIds (int array)  : get cats for given cat ids
+        :return: ids (int array)   : integer array of cat ids
+        """
+        catNms = catNms if _isArrayLike(catNms) else [catNms]
+        supNms = supNms if _isArrayLike(supNms) else [supNms]
+        catIds = catIds if _isArrayLike(catIds) else [catIds]
+
+        if len(catNms) == len(supNms) == len(catIds) == 0:
+            cats = self.dataset['categories']
+        else:
+            cats = self.dataset['categories']
+            cats = cats if len(catNms) == 0 else [cat for cat in cats if cat['name']          in catNms]
+            cats = cats if len(supNms) == 0 else [cat for cat in cats if cat['supercategory'] in supNms]
+            cats = cats if len(catIds) == 0 else [cat for cat in cats if cat['id']            in catIds]
+        ids = [cat['id'] for cat in cats]
+        return ids
+
+    def getImgIds(self, imgIds=[], catIds=[]):
+        '''
+        Get img ids that satisfy given filter conditions.
+        :param imgIds (int array) : get imgs for given ids
+        :param catIds (int array) : get imgs with all given cats
+        :return: ids (int array)  : integer array of img ids
+        '''
+        imgIds = imgIds if _isArrayLike(imgIds) else [imgIds]
+        catIds = catIds if _isArrayLike(catIds) else [catIds]
+
+        if len(imgIds) == len(catIds) == 0:
+            ids = self.imgs.keys()
+        else:
+            ids = set(imgIds)
+            for i, catId in enumerate(catIds):
+                if i == 0 and len(ids) == 0:
+                    ids = set(self.catToImgs[catId])
+                else:
+                    ids &= set(self.catToImgs[catId])
+        return list(ids)
+
+    def loadAnns(self, ids=[]):
+        """
+        Load anns with the specified ids.
+        :param ids (int array)       : integer ids specifying anns
+        :return: anns (object array) : loaded ann objects
+        """
+        if _isArrayLike(ids):
+            return [self.anns[id] for id in ids]
+        elif type(ids) == int:
+            return [self.anns[ids]]
+
+    def loadCats(self, ids=[]):
+        """
+        Load cats with the specified ids.
+        :param ids (int array)       : integer ids specifying cats
+        :return: cats (object array) : loaded cat objects
+        """
+        if _isArrayLike(ids):
+            return [self.cats[id] for id in ids]
+        elif type(ids) == int:
+            return [self.cats[ids]]
+
+    def loadImgs(self, ids=[]):
+        """
+        Load anns with the specified ids.
+        :param ids (int array)       : integer ids specifying img
+        :return: imgs (object array) : loaded img objects
+        """
+        if _isArrayLike(ids):
+            return [self.imgs[id] for id in ids]
+        elif type(ids) == int:
+            return [self.imgs[ids]]
+
+    def showAnns(self, anns):
+        """
+        Display the specified annotations.
+        :param anns (array of object): annotations to display
+        :return: None
+        """
+        if len(anns) == 0:
+            return 0
+        if 'segmentation' in anns[0] or 'keypoints' in anns[0]:
+            datasetType = 'instances'
+        elif 'caption' in anns[0]:
+            datasetType = 'captions'
+        else:
+            raise Exception('datasetType not supported')
+        if datasetType == 'instances':
+            ax = plt.gca()
+            ax.set_autoscale_on(False)
+            polygons = []
+            color = []
+            for ann in anns:
+                c = (np.random.random((1, 3))*0.6+0.4).tolist()[0]
+                if 'segmentation' in ann:
+                    if type(ann['segmentation']) == list:
+                        # polygon
+                        for seg in ann['segmentation']:
+                            poly = np.array(seg).reshape((int(len(seg)/2), 2))
+                            polygons.append(Polygon(poly))
+                            color.append(c)
+                    else:
+                        # mask
+                        t = self.imgs[ann['image_id']]
+                        if type(ann['segmentation']['counts']) == list:
+                            rle = maskUtils.frPyObjects([ann['segmentation']], t['height'], t['width'])
+                        else:
+                            rle = [ann['segmentation']]
+                        m = maskUtils.decode(rle)
+                        img = np.ones( (m.shape[0], m.shape[1], 3) )
+                        if ann['iscrowd'] == 1:
+                            color_mask = np.array([2.0,166.0,101.0])/255
+                        if ann['iscrowd'] == 0:
+                            color_mask = np.random.random((1, 3)).tolist()[0]
+                        for i in range(3):
+                            img[:,:,i] = color_mask[i]
+                        ax.imshow(np.dstack( (img, m*0.5) ))
+                if 'keypoints' in ann and type(ann['keypoints']) == list:
+                    # turn skeleton into zero-based index
+                    sks = np.array(self.loadCats(ann['category_id'])[0]['skeleton'])-1
+                    kp = np.array(ann['keypoints'])
+                    x = kp[0::3]
+                    y = kp[1::3]
+                    v = kp[2::3]
+                    for sk in sks:
+                        if np.all(v[sk]>0):
+                            plt.plot(x[sk],y[sk], linewidth=3, color=c)
+                    plt.plot(x[v>0], y[v>0],'o',markersize=8, markerfacecolor=c, markeredgecolor='k',markeredgewidth=2)
+                    plt.plot(x[v>1], y[v>1],'o',markersize=8, markerfacecolor=c, markeredgecolor=c, markeredgewidth=2)
+            p = PatchCollection(polygons, facecolor=color, linewidths=0, alpha=0.4)
+            ax.add_collection(p)
+            p = PatchCollection(polygons, facecolor='none', edgecolors=color, linewidths=2)
+            ax.add_collection(p)
+        elif datasetType == 'captions':
+            for ann in anns:
+                print(ann['caption'])
+
+    def loadRes(self, resFile):
+        """
+        Load result file and return a result api object.
+        :param   resFile (str)     : file name of result file
+        :return: res (obj)         : result api object
+        """
+        res = COCO()
+        res.dataset['images'] = [img for img in self.dataset['images']]
+
+        print('Loading and preparing results...')
+        tic = time.time()
+        if type(resFile) == str or type(resFile) == unicode:
+            anns = json.load(open(resFile))
+        elif type(resFile) == np.ndarray:
+            anns = self.loadNumpyAnnotations(resFile)
+        else:
+            anns = resFile
+        assert type(anns) == list, 'results in not an array of objects'
+        annsImgIds = [ann['image_id'] for ann in anns]
+        assert set(annsImgIds) == (set(annsImgIds) & set(self.getImgIds())), \
+               'Results do not correspond to current coco set'
+        if 'caption' in anns[0]:
+            imgIds = set([img['id'] for img in res.dataset['images']]) & set([ann['image_id'] for ann in anns])
+            res.dataset['images'] = [img for img in res.dataset['images'] if img['id'] in imgIds]
+            for id, ann in enumerate(anns):
+                ann['id'] = id+1
+        elif 'bbox' in anns[0] and not anns[0]['bbox'] == []:
+            res.dataset['categories'] = copy.deepcopy(self.dataset['categories'])
+            for id, ann in enumerate(anns):
+                bb = ann['bbox']
+                x1, x2, y1, y2 = [bb[0], bb[0]+bb[2], bb[1], bb[1]+bb[3]]
+                if not 'segmentation' in ann:
+                    ann['segmentation'] = [[x1, y1, x1, y2, x2, y2, x2, y1]]
+                ann['area'] = bb[2]*bb[3]
+                ann['id'] = id+1
+                ann['iscrowd'] = 0
+        elif 'segmentation' in anns[0]:
+            res.dataset['categories'] = copy.deepcopy(self.dataset['categories'])
+            for id, ann in enumerate(anns):
+                # now only support compressed RLE format as segmentation results
+                ann['area'] = maskUtils.area(ann['segmentation'])
+                if not 'bbox' in ann:
+                    ann['bbox'] = maskUtils.toBbox(ann['segmentation'])
+                ann['id'] = id+1
+                ann['iscrowd'] = 0
+        elif 'keypoints' in anns[0]:
+            res.dataset['categories'] = copy.deepcopy(self.dataset['categories'])
+            for id, ann in enumerate(anns):
+                s = ann['keypoints']
+                x = s[0::3]
+                y = s[1::3]
+                x0,x1,y0,y1 = np.min(x), np.max(x), np.min(y), np.max(y)
+                ann['area'] = (x1-x0)*(y1-y0)
+                ann['id'] = id + 1
+                ann['bbox'] = [x0,y0,x1-x0,y1-y0]
+        print('DONE (t={:0.2f}s)'.format(time.time()- tic))
+
+        res.dataset['annotations'] = anns
+        res.createIndex()
+        return res
+
+    def download(self, tarDir = None, imgIds = [] ):
+        '''
+        Download COCO images from mscoco.org server.
+        :param tarDir (str): COCO results directory name
+               imgIds (list): images to be downloaded
+        :return:
+        '''
+        if tarDir is None:
+            print('Please specify target directory')
+            return -1
+        if len(imgIds) == 0:
+            imgs = self.imgs.values()
+        else:
+            imgs = self.loadImgs(imgIds)
+        N = len(imgs)
+        if not os.path.exists(tarDir):
+            os.makedirs(tarDir)
+        for i, img in enumerate(imgs):
+            tic = time.time()
+            fname = os.path.join(tarDir, img['file_name'])
+            if not os.path.exists(fname):
+                urlretrieve(img['coco_url'], fname)
+            print('downloaded {}/{} images (t={:0.1f}s)'.format(i, N, time.time()- tic))
+
+    def loadNumpyAnnotations(self, data):
+        """
+        Convert result data from a numpy array [Nx7] where each row contains {imageID,x1,y1,w,h,score,class}
+        :param  data (numpy.ndarray)
+        :return: annotations (python nested list)
+        """
+        print('Converting ndarray to lists...')
+        assert(type(data) == np.ndarray)
+        print(data.shape)
+        assert(data.shape[1] == 7)
+        N = data.shape[0]
+        ann = []
+        for i in range(N):
+            if i % 1000000 == 0:
+                print('{}/{}'.format(i,N))
+            ann += [{
+                'image_id'  : int(data[i, 0]),
+                'bbox'  : [ data[i, 1], data[i, 2], data[i, 3], data[i, 4] ],
+                'score' : data[i, 5],
+                'category_id': int(data[i, 6]),
+                }]
+        return ann
+
+    def annToRLE(self, ann):
+        """
+        Convert annotation which can be polygons, uncompressed RLE to RLE.
+        :return: binary mask (numpy 2D array)
+        """
+        t = self.imgs[ann['image_id']]
+        h, w = t['height'], t['width']
+        segm = ann['segmentation']
+        if type(segm) == list:
+            # polygon -- a single object might consist of multiple parts
+            # we merge all parts into one mask rle code
+            rles = maskUtils.frPyObjects(segm, h, w)
+            rle = maskUtils.merge(rles)
+        elif type(segm['counts']) == list:
+            # uncompressed RLE
+            rle = maskUtils.frPyObjects(segm, h, w)
+        else:
+            # rle
+            rle = ann['segmentation']
+        return rle
+
+    def annToMask(self, ann):
+        """
+        Convert annotation which can be polygons, uncompressed RLE, or RLE to binary mask.
+        :return: binary mask (numpy 2D array)
+        """
+        rle = self.annToRLE(ann)
+        m = maskUtils.decode(rle)
+        return m
\ No newline at end of file
diff --git a/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/pycocotools/cocoeval.py b/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/pycocotools/cocoeval.py
new file mode 100755
index 0000000..7a4b4ad
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/pycocotools/cocoeval.py
@@ -0,0 +1,534 @@
+__author__ = 'tsungyi'
+
+import numpy as np
+import datetime
+import time
+from collections import defaultdict
+from . import mask as maskUtils
+import copy
+
+class COCOeval:
+    # Interface for evaluating detection on the Microsoft COCO dataset.
+    #
+    # The usage for CocoEval is as follows:
+    #  cocoGt=..., cocoDt=...       # load dataset and results
+    #  E = CocoEval(cocoGt,cocoDt); # initialize CocoEval object
+    #  E.params.recThrs = ...;      # set parameters as desired
+    #  E.evaluate();                # run per image evaluation
+    #  E.accumulate();              # accumulate per image results
+    #  E.summarize();               # display summary metrics of results
+    # For example usage see evalDemo.m and http://mscoco.org/.
+    #
+    # The evaluation parameters are as follows (defaults in brackets):
+    #  imgIds     - [all] N img ids to use for evaluation
+    #  catIds     - [all] K cat ids to use for evaluation
+    #  iouThrs    - [.5:.05:.95] T=10 IoU thresholds for evaluation
+    #  recThrs    - [0:.01:1] R=101 recall thresholds for evaluation
+    #  areaRng    - [...] A=4 object area ranges for evaluation
+    #  maxDets    - [1 10 100] M=3 thresholds on max detections per image
+    #  iouType    - ['segm'] set iouType to 'segm', 'bbox' or 'keypoints'
+    #  iouType replaced the now DEPRECATED useSegm parameter.
+    #  useCats    - [1] if true use category labels for evaluation
+    # Note: if useCats=0 category labels are ignored as in proposal scoring.
+    # Note: multiple areaRngs [Ax2] and maxDets [Mx1] can be specified.
+    #
+    # evaluate(): evaluates detections on every image and every category and
+    # concats the results into the "evalImgs" with fields:
+    #  dtIds      - [1xD] id for each of the D detections (dt)
+    #  gtIds      - [1xG] id for each of the G ground truths (gt)
+    #  dtMatches  - [TxD] matching gt id at each IoU or 0
+    #  gtMatches  - [TxG] matching dt id at each IoU or 0
+    #  dtScores   - [1xD] confidence of each dt
+    #  gtIgnore   - [1xG] ignore flag for each gt
+    #  dtIgnore   - [TxD] ignore flag for each dt at each IoU
+    #
+    # accumulate(): accumulates the per-image, per-category evaluation
+    # results in "evalImgs" into the dictionary "eval" with fields:
+    #  params     - parameters used for evaluation
+    #  date       - date evaluation was performed
+    #  counts     - [T,R,K,A,M] parameter dimensions (see above)
+    #  precision  - [TxRxKxAxM] precision for every evaluation setting
+    #  recall     - [TxKxAxM] max recall for every evaluation setting
+    # Note: precision and recall==-1 for settings with no gt objects.
+    #
+    # See also coco, mask, pycocoDemo, pycocoEvalDemo
+    #
+    # Microsoft COCO Toolbox.      version 2.0
+    # Data, paper, and tutorials available at:  http://mscoco.org/
+    # Code written by Piotr Dollar and Tsung-Yi Lin, 2015.
+    # Licensed under the Simplified BSD License [see coco/license.txt]
+    def __init__(self, cocoGt=None, cocoDt=None, iouType='segm'):
+        '''
+        Initialize CocoEval using coco APIs for gt and dt
+        :param cocoGt: coco object with ground truth annotations
+        :param cocoDt: coco object with detection results
+        :return: None
+        '''
+        if not iouType:
+            print('iouType not specified. use default iouType segm')
+        self.cocoGt   = cocoGt              # ground truth COCO API
+        self.cocoDt   = cocoDt              # detections COCO API
+        self.params   = {}                  # evaluation parameters
+        self.evalImgs = defaultdict(list)   # per-image per-category evaluation results [KxAxI] elements
+        self.eval     = {}                  # accumulated evaluation results
+        self._gts = defaultdict(list)       # gt for evaluation
+        self._dts = defaultdict(list)       # dt for evaluation
+        self.params = Params(iouType=iouType) # parameters
+        self._paramsEval = {}               # parameters for evaluation
+        self.stats = []                     # result summarization
+        self.ious = {}                      # ious between all gts and dts
+        if not cocoGt is None:
+            self.params.imgIds = sorted(cocoGt.getImgIds())
+            self.params.catIds = sorted(cocoGt.getCatIds())
+
+
+    def _prepare(self):
+        '''
+        Prepare ._gts and ._dts for evaluation based on params
+        :return: None
+        '''
+        def _toMask(anns, coco):
+            # modify ann['segmentation'] by reference
+            for ann in anns:
+                rle = coco.annToRLE(ann)
+                ann['segmentation'] = rle
+        p = self.params
+        if p.useCats:
+            gts=self.cocoGt.loadAnns(self.cocoGt.getAnnIds(imgIds=p.imgIds, catIds=p.catIds))
+            dts=self.cocoDt.loadAnns(self.cocoDt.getAnnIds(imgIds=p.imgIds, catIds=p.catIds))
+        else:
+            gts=self.cocoGt.loadAnns(self.cocoGt.getAnnIds(imgIds=p.imgIds))
+            dts=self.cocoDt.loadAnns(self.cocoDt.getAnnIds(imgIds=p.imgIds))
+
+        # convert ground truth to mask if iouType == 'segm'
+        if p.iouType == 'segm':
+            _toMask(gts, self.cocoGt)
+            _toMask(dts, self.cocoDt)
+        # set ignore flag
+        for gt in gts:
+            gt['ignore'] = gt['ignore'] if 'ignore' in gt else 0
+            gt['ignore'] = 'iscrowd' in gt and gt['iscrowd']
+            if p.iouType == 'keypoints':
+                gt['ignore'] = (gt['num_keypoints'] == 0) or gt['ignore']
+        self._gts = defaultdict(list)       # gt for evaluation
+        self._dts = defaultdict(list)       # dt for evaluation
+        for gt in gts:
+            self._gts[gt['image_id'], gt['category_id']].append(gt)
+        for dt in dts:
+            self._dts[dt['image_id'], dt['category_id']].append(dt)
+        self.evalImgs = defaultdict(list)   # per-image per-category evaluation results
+        self.eval     = {}                  # accumulated evaluation results
+
+    def evaluate(self):
+        '''
+        Run per image evaluation on given images and store results (a list of dict) in self.evalImgs
+        :return: None
+        '''
+        tic = time.time()
+        print('Running per image evaluation...')
+        p = self.params
+        # add backward compatibility if useSegm is specified in params
+        if not p.useSegm is None:
+            p.iouType = 'segm' if p.useSegm == 1 else 'bbox'
+            print('useSegm (deprecated) is not None. Running {} evaluation'.format(p.iouType))
+        print('Evaluate annotation type *{}*'.format(p.iouType))
+        p.imgIds = list(np.unique(p.imgIds))
+        if p.useCats:
+            p.catIds = list(np.unique(p.catIds))
+        p.maxDets = sorted(p.maxDets)
+        self.params=p
+
+        self._prepare()
+        # loop through images, area range, max detection number
+        catIds = p.catIds if p.useCats else [-1]
+
+        if p.iouType == 'segm' or p.iouType == 'bbox':
+            computeIoU = self.computeIoU
+        elif p.iouType == 'keypoints':
+            computeIoU = self.computeOks
+        self.ious = {(imgId, catId): computeIoU(imgId, catId) \
+                        for imgId in p.imgIds
+                        for catId in catIds}
+
+        evaluateImg = self.evaluateImg
+        maxDet = p.maxDets[-1]
+        self.evalImgs = [evaluateImg(imgId, catId, areaRng, maxDet)
+                 for catId in catIds
+                 for areaRng in p.areaRng
+                 for imgId in p.imgIds
+             ]
+        self._paramsEval = copy.deepcopy(self.params)
+        toc = time.time()
+        print('DONE (t={:0.2f}s).'.format(toc-tic))
+
+    def computeIoU(self, imgId, catId):
+        p = self.params
+        if p.useCats:
+            gt = self._gts[imgId,catId]
+            dt = self._dts[imgId,catId]
+        else:
+            gt = [_ for cId in p.catIds for _ in self._gts[imgId,cId]]
+            dt = [_ for cId in p.catIds for _ in self._dts[imgId,cId]]
+        if len(gt) == 0 and len(dt) ==0:
+            return []
+        inds = np.argsort([-d['score'] for d in dt], kind='mergesort')
+        dt = [dt[i] for i in inds]
+        if len(dt) > p.maxDets[-1]:
+            dt=dt[0:p.maxDets[-1]]
+
+        if p.iouType == 'segm':
+            g = [g['segmentation'] for g in gt]
+            d = [d['segmentation'] for d in dt]
+        elif p.iouType == 'bbox':
+            g = [g['bbox'] for g in gt]
+            d = [d['bbox'] for d in dt]
+        else:
+            raise Exception('unknown iouType for iou computation')
+
+        # compute iou between each dt and gt region
+        iscrowd = [int(o['iscrowd']) for o in gt]
+        ious = maskUtils.iou(d,g,iscrowd)
+        return ious
+
+    def computeOks(self, imgId, catId):
+        p = self.params
+        # dimention here should be Nxm
+        gts = self._gts[imgId, catId]
+        dts = self._dts[imgId, catId]
+        inds = np.argsort([-d['score'] for d in dts], kind='mergesort')
+        dts = [dts[i] for i in inds]
+        if len(dts) > p.maxDets[-1]:
+            dts = dts[0:p.maxDets[-1]]
+        # if len(gts) == 0 and len(dts) == 0:
+        if len(gts) == 0 or len(dts) == 0:
+            return []
+        ious = np.zeros((len(dts), len(gts)))
+        sigmas = np.array([.26, .25, .25, .35, .35, .79, .79, .72, .72, .62,.62, 1.07, 1.07, .87, .87, .89, .89])/10.0
+        vars = (sigmas * 2)**2
+        k = len(sigmas)
+        # compute oks between each detection and ground truth object
+        for j, gt in enumerate(gts):
+            # create bounds for ignore regions(double the gt bbox)
+            g = np.array(gt['keypoints'])
+            xg = g[0::3]; yg = g[1::3]; vg = g[2::3]
+            k1 = np.count_nonzero(vg > 0)
+            bb = gt['bbox']
+            x0 = bb[0] - bb[2]; x1 = bb[0] + bb[2] * 2
+            y0 = bb[1] - bb[3]; y1 = bb[1] + bb[3] * 2
+            for i, dt in enumerate(dts):
+                d = np.array(dt['keypoints'])
+                xd = d[0::3]; yd = d[1::3]
+                if k1>0:
+                    # measure the per-keypoint distance if keypoints visible
+                    dx = xd - xg
+                    dy = yd - yg
+                else:
+                    # measure minimum distance to keypoints in (x0,y0) & (x1,y1)
+                    z = np.zeros((k))
+                    dx = np.max((z, x0-xd),axis=0)+np.max((z, xd-x1),axis=0)
+                    dy = np.max((z, y0-yd),axis=0)+np.max((z, yd-y1),axis=0)
+                e = (dx**2 + dy**2) / vars / (gt['area']+np.spacing(1)) / 2
+                if k1 > 0:
+                    e=e[vg > 0]
+                ious[i, j] = np.sum(np.exp(-e)) / e.shape[0]
+        return ious
+
+    def evaluateImg(self, imgId, catId, aRng, maxDet):
+        '''
+        perform evaluation for single category and image
+        :return: dict (single image results)
+        '''
+        p = self.params
+        if p.useCats:
+            gt = self._gts[imgId,catId]
+            dt = self._dts[imgId,catId]
+        else:
+            gt = [_ for cId in p.catIds for _ in self._gts[imgId,cId]]
+            dt = [_ for cId in p.catIds for _ in self._dts[imgId,cId]]
+        if len(gt) == 0 and len(dt) ==0:
+            return None
+
+        for g in gt:
+            if g['ignore'] or (g['area']<aRng[0] or g['area']>aRng[1]):
+                g['_ignore'] = 1
+            else:
+                g['_ignore'] = 0
+
+        # sort dt highest score first, sort gt ignore last
+        gtind = np.argsort([g['_ignore'] for g in gt], kind='mergesort')
+        gt = [gt[i] for i in gtind]
+        dtind = np.argsort([-d['score'] for d in dt], kind='mergesort')
+        dt = [dt[i] for i in dtind[0:maxDet]]
+        iscrowd = [int(o['iscrowd']) for o in gt]
+        # load computed ious
+        ious = self.ious[imgId, catId][:, gtind] if len(self.ious[imgId, catId]) > 0 else self.ious[imgId, catId]
+
+        T = len(p.iouThrs)
+        G = len(gt)
+        D = len(dt)
+        gtm  = np.zeros((T,G))
+        dtm  = np.zeros((T,D))
+        gtIg = np.array([g['_ignore'] for g in gt])
+        dtIg = np.zeros((T,D))
+        if not len(ious)==0:
+            for tind, t in enumerate(p.iouThrs):
+                for dind, d in enumerate(dt):
+                    # information about best match so far (m=-1 -> unmatched)
+                    iou = min([t,1-1e-10])
+                    m   = -1
+                    for gind, g in enumerate(gt):
+                        # if this gt already matched, and not a crowd, continue
+                        if gtm[tind,gind]>0 and not iscrowd[gind]:
+                            continue
+                        # if dt matched to reg gt, and on ignore gt, stop
+                        if m>-1 and gtIg[m]==0 and gtIg[gind]==1:
+                            break
+                        # continue to next gt unless better match made
+                        if ious[dind,gind] < iou:
+                            continue
+                        # if match successful and best so far, store appropriately
+                        iou=ious[dind,gind]
+                        m=gind
+                    # if match made store id of match for both dt and gt
+                    if m ==-1:
+                        continue
+                    dtIg[tind,dind] = gtIg[m]
+                    dtm[tind,dind]  = gt[m]['id']
+                    gtm[tind,m]     = d['id']
+        # set unmatched detections outside of area range to ignore
+        a = np.array([d['area']<aRng[0] or d['area']>aRng[1] for d in dt]).reshape((1, len(dt)))
+        dtIg = np.logical_or(dtIg, np.logical_and(dtm==0, np.repeat(a,T,0)))
+        # store results for given image and category
+        return {
+                'image_id':     imgId,
+                'category_id':  catId,
+                'aRng':         aRng,
+                'maxDet':       maxDet,
+                'dtIds':        [d['id'] for d in dt],
+                'gtIds':        [g['id'] for g in gt],
+                'dtMatches':    dtm,
+                'gtMatches':    gtm,
+                'dtScores':     [d['score'] for d in dt],
+                'gtIgnore':     gtIg,
+                'dtIgnore':     dtIg,
+            }
+
+    def accumulate(self, p = None):
+        '''
+        Accumulate per image evaluation results and store the result in self.eval
+        :param p: input params for evaluation
+        :return: None
+        '''
+        print('Accumulating evaluation results...')
+        tic = time.time()
+        if not self.evalImgs:
+            print('Please run evaluate() first')
+        # allows input customized parameters
+        if p is None:
+            p = self.params
+        p.catIds = p.catIds if p.useCats == 1 else [-1]
+        T           = len(p.iouThrs)
+        R           = len(p.recThrs)
+        K           = len(p.catIds) if p.useCats else 1
+        A           = len(p.areaRng)
+        M           = len(p.maxDets)
+        precision   = -np.ones((T,R,K,A,M)) # -1 for the precision of absent categories
+        recall      = -np.ones((T,K,A,M))
+        scores      = -np.ones((T,R,K,A,M))
+
+        # create dictionary for future indexing
+        _pe = self._paramsEval
+        catIds = _pe.catIds if _pe.useCats else [-1]
+        setK = set(catIds)
+        setA = set(map(tuple, _pe.areaRng))
+        setM = set(_pe.maxDets)
+        setI = set(_pe.imgIds)
+        # get inds to evaluate
+        k_list = [n for n, k in enumerate(p.catIds)  if k in setK]
+        m_list = [m for n, m in enumerate(p.maxDets) if m in setM]
+        a_list = [n for n, a in enumerate(map(lambda x: tuple(x), p.areaRng)) if a in setA]
+        i_list = [n for n, i in enumerate(p.imgIds)  if i in setI]
+        I0 = len(_pe.imgIds)
+        A0 = len(_pe.areaRng)
+        # retrieve E at each category, area range, and max number of detections
+        for k, k0 in enumerate(k_list):
+            Nk = k0*A0*I0
+            for a, a0 in enumerate(a_list):
+                Na = a0*I0
+                for m, maxDet in enumerate(m_list):
+                    E = [self.evalImgs[Nk + Na + i] for i in i_list]
+                    E = [e for e in E if not e is None]
+                    if len(E) == 0:
+                        continue
+                    dtScores = np.concatenate([e['dtScores'][0:maxDet] for e in E])
+
+                    # different sorting method generates slightly different results.
+                    # mergesort is used to be consistent as Matlab implementation.
+                    inds = np.argsort(-dtScores, kind='mergesort')
+                    dtScoresSorted = dtScores[inds]
+
+                    dtm  = np.concatenate([e['dtMatches'][:,0:maxDet] for e in E], axis=1)[:,inds]
+                    dtIg = np.concatenate([e['dtIgnore'][:,0:maxDet]  for e in E], axis=1)[:,inds]
+                    gtIg = np.concatenate([e['gtIgnore'] for e in E])
+                    npig = np.count_nonzero(gtIg==0 )
+                    if npig == 0:
+                        continue
+                    tps = np.logical_and(               dtm,  np.logical_not(dtIg) )
+                    fps = np.logical_and(np.logical_not(dtm), np.logical_not(dtIg) )
+
+                    tp_sum = np.cumsum(tps, axis=1).astype(dtype=np.float)
+                    fp_sum = np.cumsum(fps, axis=1).astype(dtype=np.float)
+                    for t, (tp, fp) in enumerate(zip(tp_sum, fp_sum)):
+                        tp = np.array(tp)
+                        fp = np.array(fp)
+                        nd = len(tp)
+                        rc = tp / npig
+                        pr = tp / (fp+tp+np.spacing(1))
+                        q  = np.zeros((R,))
+                        ss = np.zeros((R,))
+
+                        if nd:
+                            recall[t,k,a,m] = rc[-1]
+                        else:
+                            recall[t,k,a,m] = 0
+
+                        # numpy is slow without cython optimization for accessing elements
+                        # use python array gets significant speed improvement
+                        pr = pr.tolist(); q = q.tolist()
+
+                        for i in range(nd-1, 0, -1):
+                            if pr[i] > pr[i-1]:
+                                pr[i-1] = pr[i]
+
+                        inds = np.searchsorted(rc, p.recThrs, side='left')
+                        try:
+                            for ri, pi in enumerate(inds):
+                                q[ri] = pr[pi]
+                                ss[ri] = dtScoresSorted[pi]
+                        except:
+                            pass
+                        precision[t,:,k,a,m] = np.array(q)
+                        scores[t,:,k,a,m] = np.array(ss)
+        self.eval = {
+            'params': p,
+            'counts': [T, R, K, A, M],
+            'date': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+            'precision': precision,
+            'recall':   recall,
+            'scores': scores,
+        }
+        toc = time.time()
+        print('DONE (t={:0.2f}s).'.format( toc-tic))
+
+    def summarize(self):
+        '''
+        Compute and display summary metrics for evaluation results.
+        Note this functin can *only* be applied on the default parameter setting
+        '''
+        def _summarize( ap=1, iouThr=None, areaRng='all', maxDets=100 ):
+            p = self.params
+            iStr = ' {:<18} {} @[ IoU={:<9} | area={:>6s} | maxDets={:>3d} ] = {:0.3f}'
+            titleStr = 'Average Precision' if ap == 1 else 'Average Recall'
+            typeStr = '(AP)' if ap==1 else '(AR)'
+            iouStr = '{:0.2f}:{:0.2f}'.format(p.iouThrs[0], p.iouThrs[-1]) \
+                if iouThr is None else '{:0.2f}'.format(iouThr)
+
+            aind = [i for i, aRng in enumerate(p.areaRngLbl) if aRng == areaRng]
+            mind = [i for i, mDet in enumerate(p.maxDets) if mDet == maxDets]
+            if ap == 1:
+                # dimension of precision: [TxRxKxAxM]
+                s = self.eval['precision']
+                # IoU
+                if iouThr is not None:
+                    t = np.where(iouThr == p.iouThrs)[0]
+                    s = s[t]
+                s = s[:,:,:,aind,mind]
+            else:
+                # dimension of recall: [TxKxAxM]
+                s = self.eval['recall']
+                if iouThr is not None:
+                    t = np.where(iouThr == p.iouThrs)[0]
+                    s = s[t]
+                s = s[:,:,aind,mind]
+            if len(s[s>-1])==0:
+                mean_s = -1
+            else:
+                mean_s = np.mean(s[s>-1])
+            print(iStr.format(titleStr, typeStr, iouStr, areaRng, maxDets, mean_s))
+            return mean_s
+        def _summarizeDets():
+            stats = np.zeros((12,))
+            stats[0] = _summarize(1)
+            stats[1] = _summarize(1, iouThr=.5, maxDets=self.params.maxDets[2])
+            stats[2] = _summarize(1, iouThr=.75, maxDets=self.params.maxDets[2])
+            stats[3] = _summarize(1, areaRng='small', maxDets=self.params.maxDets[2])
+            stats[4] = _summarize(1, areaRng='medium', maxDets=self.params.maxDets[2])
+            stats[5] = _summarize(1, areaRng='large', maxDets=self.params.maxDets[2])
+            stats[6] = _summarize(0, maxDets=self.params.maxDets[0])
+            stats[7] = _summarize(0, maxDets=self.params.maxDets[1])
+            stats[8] = _summarize(0, maxDets=self.params.maxDets[2])
+            stats[9] = _summarize(0, areaRng='small', maxDets=self.params.maxDets[2])
+            stats[10] = _summarize(0, areaRng='medium', maxDets=self.params.maxDets[2])
+            stats[11] = _summarize(0, areaRng='large', maxDets=self.params.maxDets[2])
+            return stats
+        def _summarizeKps():
+            stats = np.zeros((10,))
+            stats[0] = _summarize(1, maxDets=20)
+            stats[1] = _summarize(1, maxDets=20, iouThr=.5)
+            stats[2] = _summarize(1, maxDets=20, iouThr=.75)
+            stats[3] = _summarize(1, maxDets=20, areaRng='medium')
+            stats[4] = _summarize(1, maxDets=20, areaRng='large')
+            stats[5] = _summarize(0, maxDets=20)
+            stats[6] = _summarize(0, maxDets=20, iouThr=.5)
+            stats[7] = _summarize(0, maxDets=20, iouThr=.75)
+            stats[8] = _summarize(0, maxDets=20, areaRng='medium')
+            stats[9] = _summarize(0, maxDets=20, areaRng='large')
+            return stats
+        if not self.eval:
+            raise Exception('Please run accumulate() first')
+        iouType = self.params.iouType
+        if iouType == 'segm' or iouType == 'bbox':
+            summarize = _summarizeDets
+        elif iouType == 'keypoints':
+            summarize = _summarizeKps
+        self.stats = summarize()
+
+    def __str__(self):
+        self.summarize()
+
+class Params:
+    '''
+    Params for coco evaluation api
+    '''
+    def setDetParams(self):
+        self.imgIds = []
+        self.catIds = []
+        # np.arange causes trouble.  the data point on arange is slightly larger than the true value
+        self.iouThrs = np.linspace(.5, 0.95, np.round((0.95 - .5) / .05) + 1, endpoint=True)
+        self.recThrs = np.linspace(.0, 1.00, np.round((1.00 - .0) / .01) + 1, endpoint=True)
+        self.maxDets = [1, 10, 100]
+        self.areaRng = [[0 ** 2, 1e5 ** 2], [0 ** 2, 32 ** 2], [32 ** 2, 96 ** 2], [96 ** 2, 1e5 ** 2]]
+        self.areaRngLbl = ['all', 'small', 'medium', 'large']
+        self.useCats = 1
+
+    def setKpParams(self):
+        self.imgIds = []
+        self.catIds = []
+        # np.arange causes trouble.  the data point on arange is slightly larger than the true value
+        self.iouThrs = np.linspace(.5, 0.95, np.round((0.95 - .5) / .05) + 1, endpoint=True)
+        self.recThrs = np.linspace(.0, 1.00, np.round((1.00 - .0) / .01) + 1, endpoint=True)
+        self.maxDets = [20]
+        self.areaRng = [[0 ** 2, 1e5 ** 2], [32 ** 2, 96 ** 2], [96 ** 2, 1e5 ** 2]]
+        self.areaRngLbl = ['all', 'medium', 'large']
+        self.useCats = 1
+
+    def __init__(self, iouType='segm'):
+        if iouType == 'segm' or iouType == 'bbox':
+            self.setDetParams()
+        elif iouType == 'keypoints':
+            self.setKpParams()
+        else:
+            raise Exception('iouType not supported')
+        self.iouType = iouType
+        # useSegm is deprecated
+        self.useSegm = None
\ No newline at end of file
diff --git a/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/pycocotools/mask.py b/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/pycocotools/mask.py
new file mode 100755
index 0000000..40853ba
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/pycocotools/mask.py
@@ -0,0 +1,103 @@
+__author__ = 'tsungyi'
+
+import pycocotools._mask as _mask
+
+# Interface for manipulating masks stored in RLE format.
+#
+# RLE is a simple yet efficient format for storing binary masks. RLE
+# first divides a vector (or vectorized image) into a series of piecewise
+# constant regions and then for each piece simply stores the length of
+# that piece. For example, given M=[0 0 1 1 1 0 1] the RLE counts would
+# be [2 3 1 1], or for M=[1 1 1 1 1 1 0] the counts would be [0 6 1]
+# (note that the odd counts are always the numbers of zeros). Instead of
+# storing the counts directly, additional compression is achieved with a
+# variable bitrate representation based on a common scheme called LEB128.
+#
+# Compression is greatest given large piecewise constant regions.
+# Specifically, the size of the RLE is proportional to the number of
+# *boundaries* in M (or for an image the number of boundaries in the y
+# direction). Assuming fairly simple shapes, the RLE representation is
+# O(sqrt(n)) where n is number of pixels in the object. Hence space usage
+# is substantially lower, especially for large simple objects (large n).
+#
+# Many common operations on masks can be computed directly using the RLE
+# (without need for decoding). This includes computations such as area,
+# union, intersection, etc. All of these operations are linear in the
+# size of the RLE, in other words they are O(sqrt(n)) where n is the area
+# of the object. Computing these operations on the original mask is O(n).
+# Thus, using the RLE can result in substantial computational savings.
+#
+# The following API functions are defined:
+#  encode         - Encode binary masks using RLE.
+#  decode         - Decode binary masks encoded via RLE.
+#  merge          - Compute union or intersection of encoded masks.
+#  iou            - Compute intersection over union between masks.
+#  area           - Compute area of encoded masks.
+#  toBbox         - Get bounding boxes surrounding encoded masks.
+#  frPyObjects    - Convert polygon, bbox, and uncompressed RLE to encoded RLE mask.
+#
+# Usage:
+#  Rs     = encode( masks )
+#  masks  = decode( Rs )
+#  R      = merge( Rs, intersect=false )
+#  o      = iou( dt, gt, iscrowd )
+#  a      = area( Rs )
+#  bbs    = toBbox( Rs )
+#  Rs     = frPyObjects( [pyObjects], h, w )
+#
+# In the API the following formats are used:
+#  Rs      - [dict] Run-length encoding of binary masks
+#  R       - dict Run-length encoding of binary mask
+#  masks   - [hxwxn] Binary mask(s) (must have type np.ndarray(dtype=uint8) in column-major order)
+#  iscrowd - [nx1] list of np.ndarray. 1 indicates corresponding gt image has crowd region to ignore
+#  bbs     - [nx4] Bounding box(es) stored as [x y w h]
+#  poly    - Polygon stored as [[x1 y1 x2 y2...],[x1 y1 ...],...] (2D list)
+#  dt,gt   - May be either bounding boxes or encoded masks
+# Both poly and bbs are 0-indexed (bbox=[0 0 1 1] encloses first pixel).
+#
+# Finally, a note about the intersection over union (iou) computation.
+# The standard iou of a ground truth (gt) and detected (dt) object is
+#  iou(gt,dt) = area(intersect(gt,dt)) / area(union(gt,dt))
+# For "crowd" regions, we use a modified criteria. If a gt object is
+# marked as "iscrowd", we allow a dt to match any subregion of the gt.
+# Choosing gt' in the crowd gt that best matches the dt can be done using
+# gt'=intersect(dt,gt). Since by definition union(gt',dt)=dt, computing
+#  iou(gt,dt,iscrowd) = iou(gt',dt) = area(intersect(gt,dt)) / area(dt)
+# For crowd gt regions we use this modified criteria above for the iou.
+#
+# To compile run "python setup.py build_ext --inplace"
+# Please do not contact us for help with compiling.
+#
+# Microsoft COCO Toolbox.      version 2.0
+# Data, paper, and tutorials available at:  http://mscoco.org/
+# Code written by Piotr Dollar and Tsung-Yi Lin, 2015.
+# Licensed under the Simplified BSD License [see coco/license.txt]
+
+iou         = _mask.iou
+merge       = _mask.merge
+frPyObjects = _mask.frPyObjects
+
+def encode(bimask):
+    if len(bimask.shape) == 3:
+        return _mask.encode(bimask)
+    elif len(bimask.shape) == 2:
+        h, w = bimask.shape
+        return _mask.encode(bimask.reshape((h, w, 1), order='F'))[0]
+
+def decode(rleObjs):
+    if type(rleObjs) == list:
+        return _mask.decode(rleObjs)
+    else:
+        return _mask.decode([rleObjs])[:,:,0]
+
+def area(rleObjs):
+    if type(rleObjs) == list:
+        return _mask.area(rleObjs)
+    else:
+        return _mask.area([rleObjs])[0]
+
+def toBbox(rleObjs):
+    if type(rleObjs) == list:
+        return _mask.toBbox(rleObjs)
+    else:
+        return _mask.toBbox([rleObjs])[0]
\ No newline at end of file
diff --git a/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/setup.py b/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/setup.py
new file mode 100755
index 0000000..dbf0093
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/data/lib_coco/PythonAPI/setup.py
@@ -0,0 +1,27 @@
+from setuptools import setup, Extension
+import numpy as np
+
+# To compile and install locally run "python setup.py build_ext --inplace"
+# To install library to Python site-packages run "python setup.py build_ext install"
+
+ext_modules = [
+    Extension(
+        'pycocotools._mask',
+        sources=['../common/maskApi.c', 'pycocotools/_mask.pyx'],
+        include_dirs = [np.get_include(), '../common'],
+        extra_compile_args=['-Wno-cpp', '-Wno-unused-function', '-std=c99'],
+    )
+]
+
+setup(
+    name='pycocotools',
+    packages=['pycocotools'],
+    package_dir = {'pycocotools': 'pycocotools'},
+    install_requires=[
+        'setuptools>=18.0',
+        'cython>=0.27.3',
+        'matplotlib>=2.1.0'
+    ],
+    version='2.0',
+    ext_modules= ext_modules
+)
diff --git a/example-apps/PDD/pcb-defect-detection/data/lib_coco/__init__.py b/example-apps/PDD/pcb-defect-detection/data/lib_coco/__init__.py
new file mode 100755
index 0000000..e69de29
diff --git a/example-apps/PDD/pcb-defect-detection/data/lib_coco/common/gason.cpp b/example-apps/PDD/pcb-defect-detection/data/lib_coco/common/gason.cpp
new file mode 100755
index 0000000..0f2c00e
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/data/lib_coco/common/gason.cpp
@@ -0,0 +1,335 @@
+// https://github.com/vivkin/gason - pulled January 10, 2016
+#include "gason.h"
+#include <stdlib.h>
+
+#define JSON_ZONE_SIZE 4096
+#define JSON_STACK_SIZE 32
+
+const char *jsonStrError(int err) {
+    switch (err) {
+#define XX(no, str) \
+    case JSON_##no: \
+        return str;
+        JSON_ERRNO_MAP(XX)
+#undef XX
+    default:
+        return "unknown";
+    }
+}
+
+void *JsonAllocator::allocate(size_t size) {
+    size = (size + 7) & ~7;
+
+    if (head && head->used + size <= JSON_ZONE_SIZE) {
+        char *p = (char *)head + head->used;
+        head->used += size;
+        return p;
+    }
+
+    size_t allocSize = sizeof(Zone) + size;
+    Zone *zone = (Zone *)malloc(allocSize <= JSON_ZONE_SIZE ? JSON_ZONE_SIZE : allocSize);
+    if (zone == nullptr)
+        return nullptr;
+    zone->used = allocSize;
+    if (allocSize <= JSON_ZONE_SIZE || head == nullptr) {
+        zone->next = head;
+        head = zone;
+    } else {
+        zone->next = head->next;
+        head->next = zone;
+    }
+    return (char *)zone + sizeof(Zone);
+}
+
+void JsonAllocator::deallocate() {
+    while (head) {
+        Zone *next = head->next;
+        free(head);
+        head = next;
+    }
+}
+
+static inline bool isspace(char c) {
+    return c == ' ' || (c >= '\t' && c <= '\r');
+}
+
+static inline bool isdelim(char c) {
+    return c == ',' || c == ':' || c == ']' || c == '}' || isspace(c) || !c;
+}
+
+static inline bool isdigit(char c) {
+    return c >= '0' && c <= '9';
+}
+
+static inline bool isxdigit(char c) {
+    return (c >= '0' && c <= '9') || ((c & ~' ') >= 'A' && (c & ~' ') <= 'F');
+}
+
+static inline int char2int(char c) {
+    if (c <= '9')
+        return c - '0';
+    return (c & ~' ') - 'A' + 10;
+}
+
+static double string2double(char *s, char **endptr) {
+    char ch = *s;
+    if (ch == '-')
+        ++s;
+
+    double result = 0;
+    while (isdigit(*s))
+        result = (result * 10) + (*s++ - '0');
+
+    if (*s == '.') {
+        ++s;
+
+        double fraction = 1;
+        while (isdigit(*s)) {
+            fraction *= 0.1;
+            result += (*s++ - '0') * fraction;
+        }
+    }
+
+    if (*s == 'e' || *s == 'E') {
+        ++s;
+
+        double base = 10;
+        if (*s == '+')
+            ++s;
+        else if (*s == '-') {
+            ++s;
+            base = 0.1;
+        }
+
+        unsigned int exponent = 0;
+        while (isdigit(*s))
+            exponent = (exponent * 10) + (*s++ - '0');
+
+        double power = 1;
+        for (; exponent; exponent >>= 1, base *= base)
+            if (exponent & 1)
+                power *= base;
+
+        result *= power;
+    }
+
+    *endptr = s;
+    return ch == '-' ? -result : result;
+}
+
+static inline JsonNode *insertAfter(JsonNode *tail, JsonNode *node) {
+    if (!tail)
+        return node->next = node;
+    node->next = tail->next;
+    tail->next = node;
+    return node;
+}
+
+static inline JsonValue listToValue(JsonTag tag, JsonNode *tail) {
+    if (tail) {
+        auto head = tail->next;
+        tail->next = nullptr;
+        return JsonValue(tag, head);
+    }
+    return JsonValue(tag, nullptr);
+}
+
+int jsonParse(char *s, char **endptr, JsonValue *value, JsonAllocator &allocator) {
+    JsonNode *tails[JSON_STACK_SIZE];
+    JsonTag tags[JSON_STACK_SIZE];
+    char *keys[JSON_STACK_SIZE];
+    JsonValue o;
+    int pos = -1;
+    bool separator = true;
+    JsonNode *node;
+    *endptr = s;
+
+    while (*s) {
+        while (isspace(*s)) {
+            ++s;
+            if (!*s) break;
+        }
+        *endptr = s++;
+        switch (**endptr) {
+        case '-':
+            if (!isdigit(*s) && *s != '.') {
+                *endptr = s;
+                return JSON_BAD_NUMBER;
+            }
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9':
+            o = JsonValue(string2double(*endptr, &s));
+            if (!isdelim(*s)) {
+                *endptr = s;
+                return JSON_BAD_NUMBER;
+            }
+            break;
+        case '"':
+            o = JsonValue(JSON_STRING, s);
+            for (char *it = s; *s; ++it, ++s) {
+                int c = *it = *s;
+                if (c == '\\') {
+                    c = *++s;
+                    switch (c) {
+                    case '\\':
+                    case '"':
+                    case '/':
+                        *it = c;
+                        break;
+                    case 'b':
+                        *it = '\b';
+                        break;
+                    case 'f':
+                        *it = '\f';
+                        break;
+                    case 'n':
+                        *it = '\n';
+                        break;
+                    case 'r':
+                        *it = '\r';
+                        break;
+                    case 't':
+                        *it = '\t';
+                        break;
+                    case 'u':
+                        c = 0;
+                        for (int i = 0; i < 4; ++i) {
+                            if (isxdigit(*++s)) {
+                                c = c * 16 + char2int(*s);
+                            } else {
+                                *endptr = s;
+                                return JSON_BAD_STRING;
+                            }
+                        }
+                        if (c < 0x80) {
+                            *it = c;
+                        } else if (c < 0x800) {
+                            *it++ = 0xC0 | (c >> 6);
+                            *it = 0x80 | (c & 0x3F);
+                        } else {
+                            *it++ = 0xE0 | (c >> 12);
+                            *it++ = 0x80 | ((c >> 6) & 0x3F);
+                            *it = 0x80 | (c & 0x3F);
+                        }
+                        break;
+                    default:
+                        *endptr = s;
+                        return JSON_BAD_STRING;
+                    }
+                } else if ((unsigned int)c < ' ' || c == '\x7F') {
+                    *endptr = s;
+                    return JSON_BAD_STRING;
+                } else if (c == '"') {
+                    *it = 0;
+                    ++s;
+                    break;
+                }
+            }
+            if (!isdelim(*s)) {
+                *endptr = s;
+                return JSON_BAD_STRING;
+            }
+            break;
+        case 't':
+            if (!(s[0] == 'r' && s[1] == 'u' && s[2] == 'e' && isdelim(s[3])))
+                return JSON_BAD_IDENTIFIER;
+            o = JsonValue(JSON_TRUE);
+            s += 3;
+            break;
+        case 'f':
+            if (!(s[0] == 'a' && s[1] == 'l' && s[2] == 's' && s[3] == 'e' && isdelim(s[4])))
+                return JSON_BAD_IDENTIFIER;
+            o = JsonValue(JSON_FALSE);
+            s += 4;
+            break;
+        case 'n':
+            if (!(s[0] == 'u' && s[1] == 'l' && s[2] == 'l' && isdelim(s[3])))
+                return JSON_BAD_IDENTIFIER;
+            o = JsonValue(JSON_NULL);
+            s += 3;
+            break;
+        case ']':
+            if (pos == -1)
+                return JSON_STACK_UNDERFLOW;
+            if (tags[pos] != JSON_ARRAY)
+                return JSON_MISMATCH_BRACKET;
+            o = listToValue(JSON_ARRAY, tails[pos--]);
+            break;
+        case '}':
+            if (pos == -1)
+                return JSON_STACK_UNDERFLOW;
+            if (tags[pos] != JSON_OBJECT)
+                return JSON_MISMATCH_BRACKET;
+            if (keys[pos] != nullptr)
+                return JSON_UNEXPECTED_CHARACTER;
+            o = listToValue(JSON_OBJECT, tails[pos--]);
+            break;
+        case '[':
+            if (++pos == JSON_STACK_SIZE)
+                return JSON_STACK_OVERFLOW;
+            tails[pos] = nullptr;
+            tags[pos] = JSON_ARRAY;
+            keys[pos] = nullptr;
+            separator = true;
+            continue;
+        case '{':
+            if (++pos == JSON_STACK_SIZE)
+                return JSON_STACK_OVERFLOW;
+            tails[pos] = nullptr;
+            tags[pos] = JSON_OBJECT;
+            keys[pos] = nullptr;
+            separator = true;
+            continue;
+        case ':':
+            if (separator || keys[pos] == nullptr)
+                return JSON_UNEXPECTED_CHARACTER;
+            separator = true;
+            continue;
+        case ',':
+            if (separator || keys[pos] != nullptr)
+                return JSON_UNEXPECTED_CHARACTER;
+            separator = true;
+            continue;
+        case '\0':
+            continue;
+        default:
+            return JSON_UNEXPECTED_CHARACTER;
+        }
+
+        separator = false;
+
+        if (pos == -1) {
+            *endptr = s;
+            *value = o;
+            return JSON_OK;
+        }
+
+        if (tags[pos] == JSON_OBJECT) {
+            if (!keys[pos]) {
+                if (o.getTag() != JSON_STRING)
+                    return JSON_UNQUOTED_KEY;
+                keys[pos] = o.toString();
+                continue;
+            }
+            if ((node = (JsonNode *) allocator.allocate(sizeof(JsonNode))) == nullptr)
+                return JSON_ALLOCATION_FAILURE;
+            tails[pos] = insertAfter(tails[pos], node);
+            tails[pos]->key = keys[pos];
+            keys[pos] = nullptr;
+        } else {
+            if ((node = (JsonNode *) allocator.allocate(sizeof(JsonNode) - sizeof(char *))) == nullptr)
+                return JSON_ALLOCATION_FAILURE;
+            tails[pos] = insertAfter(tails[pos], node);
+        }
+        tails[pos]->value = o;
+    }
+    return JSON_BREAKING_BAD;
+}
diff --git a/example-apps/PDD/pcb-defect-detection/data/lib_coco/common/gason.h b/example-apps/PDD/pcb-defect-detection/data/lib_coco/common/gason.h
new file mode 100755
index 0000000..2e728d9
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/data/lib_coco/common/gason.h
@@ -0,0 +1,136 @@
+// https://github.com/vivkin/gason - pulled January 10, 2016
+#pragma once
+
+#include <stdint.h>
+#include <stddef.h>
+#include <assert.h>
+
+enum JsonTag {
+    JSON_NUMBER = 0,
+    JSON_STRING,
+    JSON_ARRAY,
+    JSON_OBJECT,
+    JSON_TRUE,
+    JSON_FALSE,
+    JSON_NULL = 0xF
+};
+
+struct JsonNode;
+
+#define JSON_VALUE_PAYLOAD_MASK 0x00007FFFFFFFFFFFULL
+#define JSON_VALUE_NAN_MASK 0x7FF8000000000000ULL
+#define JSON_VALUE_TAG_MASK 0xF
+#define JSON_VALUE_TAG_SHIFT 47
+
+union JsonValue {
+    uint64_t ival;
+    double fval;
+
+    JsonValue(double x)
+        : fval(x) {
+    }
+    JsonValue(JsonTag tag = JSON_NULL, void *payload = nullptr) {
+        assert((uintptr_t)payload <= JSON_VALUE_PAYLOAD_MASK);
+        ival = JSON_VALUE_NAN_MASK | ((uint64_t)tag << JSON_VALUE_TAG_SHIFT) | (uintptr_t)payload;
+    }
+    bool isDouble() const {
+        return (int64_t)ival <= (int64_t)JSON_VALUE_NAN_MASK;
+    }
+    JsonTag getTag() const {
+        return isDouble() ? JSON_NUMBER : JsonTag((ival >> JSON_VALUE_TAG_SHIFT) & JSON_VALUE_TAG_MASK);
+    }
+    uint64_t getPayload() const {
+        assert(!isDouble());
+        return ival & JSON_VALUE_PAYLOAD_MASK;
+    }
+    double toNumber() const {
+        assert(getTag() == JSON_NUMBER);
+        return fval;
+    }
+    char *toString() const {
+        assert(getTag() == JSON_STRING);
+        return (char *)getPayload();
+    }
+    JsonNode *toNode() const {
+        assert(getTag() == JSON_ARRAY || getTag() == JSON_OBJECT);
+        return (JsonNode *)getPayload();
+    }
+};
+
+struct JsonNode {
+    JsonValue value;
+    JsonNode *next;
+    char *key;
+};
+
+struct JsonIterator {
+    JsonNode *p;
+
+    void operator++() {
+        p = p->next;
+    }
+    bool operator!=(const JsonIterator &x) const {
+        return p != x.p;
+    }
+    JsonNode *operator*() const {
+        return p;
+    }
+    JsonNode *operator->() const {
+        return p;
+    }
+};
+
+inline JsonIterator begin(JsonValue o) {
+    return JsonIterator{o.toNode()};
+}
+inline JsonIterator end(JsonValue) {
+    return JsonIterator{nullptr};
+}
+
+#define JSON_ERRNO_MAP(XX)                           \
+    XX(OK, "ok")                                     \
+    XX(BAD_NUMBER, "bad number")                     \
+    XX(BAD_STRING, "bad string")                     \
+    XX(BAD_IDENTIFIER, "bad identifier")             \
+    XX(STACK_OVERFLOW, "stack overflow")             \
+    XX(STACK_UNDERFLOW, "stack underflow")           \
+    XX(MISMATCH_BRACKET, "mismatch bracket")         \
+    XX(UNEXPECTED_CHARACTER, "unexpected character") \
+    XX(UNQUOTED_KEY, "unquoted key")                 \
+    XX(BREAKING_BAD, "breaking bad")                 \
+    XX(ALLOCATION_FAILURE, "allocation failure")
+
+enum JsonErrno {
+#define XX(no, str) JSON_##no,
+    JSON_ERRNO_MAP(XX)
+#undef XX
+};
+
+const char *jsonStrError(int err);
+
+class JsonAllocator {
+    struct Zone {
+        Zone *next;
+        size_t used;
+    } *head = nullptr;
+
+public:
+    JsonAllocator() = default;
+    JsonAllocator(const JsonAllocator &) = delete;
+    JsonAllocator &operator=(const JsonAllocator &) = delete;
+    JsonAllocator(JsonAllocator &&x) : head(x.head) {
+        x.head = nullptr;
+    }
+    JsonAllocator &operator=(JsonAllocator &&x) {
+        head = x.head;
+        x.head = nullptr;
+        return *this;
+    }
+    ~JsonAllocator() {
+        deallocate();
+    }
+    void *allocate(size_t size);
+    void deallocate();
+};
+
+int jsonParse(char *str, char **endptr, JsonValue *value, JsonAllocator &allocator);
diff --git a/example-apps/PDD/pcb-defect-detection/data/lib_coco/common/maskApi.c b/example-apps/PDD/pcb-defect-detection/data/lib_coco/common/maskApi.c
new file mode 100755
index 0000000..85e3979
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/data/lib_coco/common/maskApi.c
@@ -0,0 +1,230 @@
+/**************************************************************************
+* Microsoft COCO Toolbox.      version 2.0
+* Data, paper, and tutorials available at:  http://mscoco.org/
+* Code written by Piotr Dollar and Tsung-Yi Lin, 2015.
+* Licensed under the Simplified BSD License [see coco/license.txt]
+**************************************************************************/
+#include "maskApi.h"
+#include <math.h>
+#include <stdlib.h>
+
+uint umin( uint a, uint b ) { return (a<b) ? a : b; }
+uint umax( uint a, uint b ) { return (a>b) ? a : b; }
+
+void rleInit( RLE *R, siz h, siz w, siz m, uint *cnts ) {
+  R->h=h; R->w=w; R->m=m; R->cnts=(m==0)?0:malloc(sizeof(uint)*m);
+  siz j; if(cnts) for(j=0; j<m; j++) R->cnts[j]=cnts[j];
+}
+
+void rleFree( RLE *R ) {
+  free(R->cnts); R->cnts=0;
+}
+
+void rlesInit( RLE **R, siz n ) {
+  siz i; *R = (RLE*) malloc(sizeof(RLE)*n);
+  for(i=0; i<n; i++) rleInit((*R)+i,0,0,0,0);
+}
+
+void rlesFree( RLE **R, siz n ) {
+  siz i; for(i=0; i<n; i++) rleFree((*R)+i); free(*R); *R=0;
+}
+
+void rleEncode( RLE *R, const byte *M, siz h, siz w, siz n ) {
+  siz i, j, k, a=w*h; uint c, *cnts; byte p;
+  cnts = malloc(sizeof(uint)*(a+1));
+  for(i=0; i<n; i++) {
+    const byte *T=M+a*i; k=0; p=0; c=0;
+    for(j=0; j<a; j++) { if(T[j]!=p) { cnts[k++]=c; c=0; p=T[j]; } c++; }
+    cnts[k++]=c; rleInit(R+i,h,w,k,cnts);
+  }
+  free(cnts);
+}
+
+void rleDecode( const RLE *R, byte *M, siz n ) {
+  siz i, j, k; for( i=0; i<n; i++ ) {
+    byte v=0; for( j=0; j<R[i].m; j++ ) {
+      for( k=0; k<R[i].cnts[j]; k++ ) *(M++)=v; v=!v; }}
+}
+
+void rleMerge( const RLE *R, RLE *M, siz n, int intersect ) {
+  uint *cnts, c, ca, cb, cc, ct; int v, va, vb, vp;
+  siz i, a, b, h=R[0].h, w=R[0].w, m=R[0].m; RLE A, B;
+  if(n==0) { rleInit(M,0,0,0,0); return; }
+  if(n==1) { rleInit(M,h,w,m,R[0].cnts); return; }
+  cnts = malloc(sizeof(uint)*(h*w+1));
+  for( a=0; a<m; a++ ) cnts[a]=R[0].cnts[a];
+  for( i=1; i<n; i++ ) {
+    B=R[i]; if(B.h!=h||B.w!=w) { h=w=m=0; break; }
+    rleInit(&A,h,w,m,cnts); ca=A.cnts[0]; cb=B.cnts[0];
+    v=va=vb=0; m=0; a=b=1; cc=0; ct=1;
+    while( ct>0 ) {
+      c=umin(ca,cb); cc+=c; ct=0;
+      ca-=c; if(!ca && a<A.m) { ca=A.cnts[a++]; va=!va; } ct+=ca;
+      cb-=c; if(!cb && b<B.m) { cb=B.cnts[b++]; vb=!vb; } ct+=cb;
+      vp=v; if(intersect) v=va&&vb; else v=va||vb;
+      if( v!=vp||ct==0 ) { cnts[m++]=cc; cc=0; }
+    }
+    rleFree(&A);
+  }
+  rleInit(M,h,w,m,cnts); free(cnts);
+}
+
+void rleArea( const RLE *R, siz n, uint *a ) {
+  siz i, j; for( i=0; i<n; i++ ) {
+    a[i]=0; for( j=1; j<R[i].m; j+=2 ) a[i]+=R[i].cnts[j]; }
+}
+
+void rleIou( RLE *dt, RLE *gt, siz m, siz n, byte *iscrowd, double *o ) {
+  siz g, d; BB db, gb; int crowd;
+  db=malloc(sizeof(double)*m*4); rleToBbox(dt,db,m);
+  gb=malloc(sizeof(double)*n*4); rleToBbox(gt,gb,n);
+  bbIou(db,gb,m,n,iscrowd,o); free(db); free(gb);
+  for( g=0; g<n; g++ ) for( d=0; d<m; d++ ) if(o[g*m+d]>0) {
+    crowd=iscrowd!=NULL && iscrowd[g];
+    if(dt[d].h!=gt[g].h || dt[d].w!=gt[g].w) { o[g*m+d]=-1; continue; }
+    siz ka, kb, a, b; uint c, ca, cb, ct, i, u; int va, vb;
+    ca=dt[d].cnts[0]; ka=dt[d].m; va=vb=0;
+    cb=gt[g].cnts[0]; kb=gt[g].m; a=b=1; i=u=0; ct=1;
+    while( ct>0 ) {
+      c=umin(ca,cb); if(va||vb) { u+=c; if(va&&vb) i+=c; } ct=0;
+      ca-=c; if(!ca && a<ka) { ca=dt[d].cnts[a++]; va=!va; } ct+=ca;
+      cb-=c; if(!cb && b<kb) { cb=gt[g].cnts[b++]; vb=!vb; } ct+=cb;
+    }
+    if(i==0) u=1; else if(crowd) rleArea(dt+d,1,&u);
+    o[g*m+d] = (double)i/(double)u;
+  }
+}
+
+void rleNms( RLE *dt, siz n, uint *keep, double thr ) {
+  siz i, j; double u;
+  for( i=0; i<n; i++ ) keep[i]=1;
+  for( i=0; i<n; i++ ) if(keep[i]) {
+    for( j=i+1; j<n; j++ ) if(keep[j]) {
+      rleIou(dt+i,dt+j,1,1,0,&u);
+      if(u>thr) keep[j]=0;
+    }
+  }
+}
+
+void bbIou( BB dt, BB gt, siz m, siz n, byte *iscrowd, double *o ) {
+  double h, w, i, u, ga, da; siz g, d; int crowd;
+  for( g=0; g<n; g++ ) {
+    BB G=gt+g*4; ga=G[2]*G[3]; crowd=iscrowd!=NULL && iscrowd[g];
+    for( d=0; d<m; d++ ) {
+      BB D=dt+d*4; da=D[2]*D[3]; o[g*m+d]=0;
+      w=fmin(D[2]+D[0],G[2]+G[0])-fmax(D[0],G[0]); if(w<=0) continue;
+      h=fmin(D[3]+D[1],G[3]+G[1])-fmax(D[1],G[1]); if(h<=0) continue;
+      i=w*h; u = crowd ? da : da+ga-i; o[g*m+d]=i/u;
+    }
+  }
+}
+
+void bbNms( BB dt, siz n, uint *keep, double thr ) {
+  siz i, j; double u;
+  for( i=0; i<n; i++ ) keep[i]=1;
+  for( i=0; i<n; i++ ) if(keep[i]) {
+    for( j=i+1; j<n; j++ ) if(keep[j]) {
+      bbIou(dt+i*4,dt+j*4,1,1,0,&u);
+      if(u>thr) keep[j]=0;
+    }
+  }
+}
+
+void rleToBbox( const RLE *R, BB bb, siz n ) {
+  siz i; for( i=0; i<n; i++ ) {
+    uint h, w, x, y, xs, ys, xe, ye, cc, t; siz j, m;
+    h=(uint)R[i].h; w=(uint)R[i].w; m=R[i].m;
+    m=((siz)(m/2))*2; xs=w; ys=h; xe=ye=0; cc=0;
+    if(m==0) { bb[4*i+0]=bb[4*i+1]=bb[4*i+2]=bb[4*i+3]=0; continue; }
+    for( j=0; j<m; j++ ) {
+      cc+=R[i].cnts[j]; t=cc-j%2; y=t%h; x=(t-y)/h;
+      xs=umin(xs,x); xe=umax(xe,x); ys=umin(ys,y); ye=umax(ye,y);
+    }
+    bb[4*i+0]=xs; bb[4*i+2]=xe-xs+1;
+    bb[4*i+1]=ys; bb[4*i+3]=ye-ys+1;
+  }
+}
+
+void rleFrBbox( RLE *R, const BB bb, siz h, siz w, siz n ) {
+  siz i; for( i=0; i<n; i++ ) {
+    double xs=bb[4*i+0], xe=xs+bb[4*i+2];
+    double ys=bb[4*i+1], ye=ys+bb[4*i+3];
+    double xy[8] = {xs,ys,xs,ye,xe,ye,xe,ys};
+    rleFrPoly( R+i, xy, 4, h, w );
+  }
+}
+
+int uintCompare(const void *a, const void *b) {
+  uint c=*((uint*)a), d=*((uint*)b); return c>d?1:c<d?-1:0;
+}
+
+void rleFrPoly( RLE *R, const double *xy, siz k, siz h, siz w ) {
+  /* upsample and get discrete points densely along entire boundary */
+  siz j, m=0; double scale=5; int *x, *y, *u, *v; uint *a, *b;
+  x=malloc(sizeof(int)*(k+1)); y=malloc(sizeof(int)*(k+1));
+  for(j=0; j<k; j++) x[j]=(int)(scale*xy[j*2+0]+.5); x[k]=x[0];
+  for(j=0; j<k; j++) y[j]=(int)(scale*xy[j*2+1]+.5); y[k]=y[0];
+  for(j=0; j<k; j++) m+=umax(abs(x[j]-x[j+1]),abs(y[j]-y[j+1]))+1;
+  u=malloc(sizeof(int)*m); v=malloc(sizeof(int)*m); m=0;
+  for( j=0; j<k; j++ ) {
+    int xs=x[j], xe=x[j+1], ys=y[j], ye=y[j+1], dx, dy, t, d;
+    int flip; double s; dx=abs(xe-xs); dy=abs(ys-ye);
+    flip = (dx>=dy && xs>xe) || (dx<dy && ys>ye);
+    if(flip) { t=xs; xs=xe; xe=t; t=ys; ys=ye; ye=t; }
+    s = dx>=dy ? (double)(ye-ys)/dx : (double)(xe-xs)/dy;
+    if(dx>=dy) for( d=0; d<=dx; d++ ) {
+      t=flip?dx-d:d; u[m]=t+xs; v[m]=(int)(ys+s*t+.5); m++;
+    } else for( d=0; d<=dy; d++ ) {
+      t=flip?dy-d:d; v[m]=t+ys; u[m]=(int)(xs+s*t+.5); m++;
+    }
+  }
+  /* get points along y-boundary and downsample */
+  free(x); free(y); k=m; m=0; double xd, yd;
+  x=malloc(sizeof(int)*k); y=malloc(sizeof(int)*k);
+  for( j=1; j<k; j++ ) if(u[j]!=u[j-1]) {
+    xd=(double)(u[j]<u[j-1]?u[j]:u[j]-1); xd=(xd+.5)/scale-.5;
+    if( floor(xd)!=xd || xd<0 || xd>w-1 ) continue;
+    yd=(double)(v[j]<v[j-1]?v[j]:v[j-1]); yd=(yd+.5)/scale-.5;
+    if(yd<0) yd=0; else if(yd>h) yd=h; yd=ceil(yd);
+    x[m]=(int) xd; y[m]=(int) yd; m++;
+  }
+  /* compute rle encoding given y-boundary points */
+  k=m; a=malloc(sizeof(uint)*(k+1));
+  for( j=0; j<k; j++ ) a[j]=(uint)(x[j]*(int)(h)+y[j]);
+  a[k++]=(uint)(h*w); free(u); free(v); free(x); free(y);
+  qsort(a,k,sizeof(uint),uintCompare); uint p=0;
+  for( j=0; j<k; j++ ) { uint t=a[j]; a[j]-=p; p=t; }
+  b=malloc(sizeof(uint)*k); j=m=0; b[m++]=a[j++];
+  while(j<k) if(a[j]>0) b[m++]=a[j++]; else {
+    j++; if(j<k) b[m-1]+=a[j++]; }
+  rleInit(R,h,w,m,b); free(a); free(b);
+}
+
+char* rleToString( const RLE *R ) {
+  /* Similar to LEB128 but using 6 bits/char and ascii chars 48-111. */
+  siz i, m=R->m, p=0; long x; int more;
+  char *s=malloc(sizeof(char)*m*6);
+  for( i=0; i<m; i++ ) {
+    x=(long) R->cnts[i]; if(i>2) x-=(long) R->cnts[i-2]; more=1;
+    while( more ) {
+      char c=x & 0x1f; x >>= 5; more=(c & 0x10) ? x!=-1 : x!=0;
+      if(more) c |= 0x20; c+=48; s[p++]=c;
+    }
+  }
+  s[p]=0; return s;
+}
+
+void rleFrString( RLE *R, char *s, siz h, siz w ) {
+  siz m=0, p=0, k; long x; int more; uint *cnts;
+  while( s[m] ) m++; cnts=malloc(sizeof(uint)*m); m=0;
+  while( s[p] ) {
+    x=0; k=0; more=1;
+    while( more ) {
+      char c=s[p]-48; x |= (c & 0x1f) << 5*k;
+      more = c & 0x20; p++; k++;
+      if(!more && (c & 0x10)) x |= -1 << 5*k;
+    }
+    if(m>2) x+=(long) cnts[m-2]; cnts[m++]=(uint) x;
+  }
+  rleInit(R,h,w,m,cnts); free(cnts);
+}
diff --git a/example-apps/PDD/pcb-defect-detection/data/lib_coco/common/maskApi.h b/example-apps/PDD/pcb-defect-detection/data/lib_coco/common/maskApi.h
new file mode 100755
index 0000000..ebc7892
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/data/lib_coco/common/maskApi.h
@@ -0,0 +1,60 @@
+/**************************************************************************
+* Microsoft COCO Toolbox.      version 2.0
+* Data, paper, and tutorials available at:  http://mscoco.org/
+* Code written by Piotr Dollar and Tsung-Yi Lin, 2015.
+* Licensed under the Simplified BSD License [see coco/license.txt]
+**************************************************************************/
+#pragma once
+
+typedef unsigned int uint;
+typedef unsigned long siz;
+typedef unsigned char byte;
+typedef double* BB;
+typedef struct { siz h, w, m; uint *cnts; } RLE;
+
+/* Initialize/destroy RLE. */
+void rleInit( RLE *R, siz h, siz w, siz m, uint *cnts );
+void rleFree( RLE *R );
+
+/* Initialize/destroy RLE array. */
+void rlesInit( RLE **R, siz n );
+void rlesFree( RLE **R, siz n );
+
+/* Encode binary masks using RLE. */
+void rleEncode( RLE *R, const byte *mask, siz h, siz w, siz n );
+
+/* Decode binary masks encoded via RLE. */
+void rleDecode( const RLE *R, byte *mask, siz n );
+
+/* Compute union or intersection of encoded masks. */
+void rleMerge( const RLE *R, RLE *M, siz n, int intersect );
+
+/* Compute area of encoded masks. */
+void rleArea( const RLE *R, siz n, uint *a );
+
+/* Compute intersection over union between masks. */
+void rleIou( RLE *dt, RLE *gt, siz m, siz n, byte *iscrowd, double *o );
+
+/* Compute non-maximum suppression between bounding masks */
+void rleNms( RLE *dt, siz n, uint *keep, double thr );
+
+/* Compute intersection over union between bounding boxes. */
+void bbIou( BB dt, BB gt, siz m, siz n, byte *iscrowd, double *o );
+
+/* Compute non-maximum suppression between bounding boxes */
+void bbNms( BB dt, siz n, uint *keep, double thr );
+
+/* Get bounding boxes surrounding encoded masks. */
+void rleToBbox( const RLE *R, BB bb, siz n );
+
+/* Convert bounding boxes to encoded masks. */
+void rleFrBbox( RLE *R, const BB bb, siz h, siz w, siz n );
+
+/* Convert polygon to encoded mask. */
+void rleFrPoly( RLE *R, const double *xy, siz k, siz h, siz w );
+
+/* Get compressed string representation of encoded mask. */
+char* rleToString( const RLE *R );
+
+/* Convert from compressed string representation of encoded mask. */
+void rleFrString( RLE *R, char *s, siz h, siz w );
diff --git a/example-apps/PDD/pcb-defect-detection/data/lib_coco/get_coco_next_batch.py b/example-apps/PDD/pcb-defect-detection/data/lib_coco/get_coco_next_batch.py
new file mode 100755
index 0000000..ec56b1a
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/data/lib_coco/get_coco_next_batch.py
@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import, print_function, division
+
+import sys, os
+# sys.path.insert(0, os.path.abspath('.'))
+sys.path.insert(0, './PythonAPI/')
+# sys.path.insert(0, os.path.abspath('data'))
+for _ in sys.path:
+    print (_)
+from PythonAPI.pycocotools.coco import COCO
+import cv2
+import numpy as np
+import os
+from libs.label_name_dict import coco_dict
+
+
+annotation_path = '/home/yjr/DataSet/COCO/2017/annotations/instances_train2017.json'
+print ("load coco .... it will cost about 17s..")
+coco = COCO(annotation_path)
+
+imgId_list = coco.getImgIds()
+imgId_list = np.array(imgId_list)
+
+total_imgs = len(imgId_list)
+
+# print (NAME_LABEL_DICT)
+
+
+def next_img(step):
+
+    if step % total_imgs == 0:
+        np.random.shuffle(imgId_list)
+    imgid = imgId_list[step % total_imgs]
+
+    imgname = coco.loadImgs(ids=[imgid])[0]['file_name']
+    # print (type(imgname), imgname)
+    img = cv2.imread(os.path.join("/home/yjr/DataSet/COCO/2017/train2017", imgname))
+
+    annotation = coco.imgToAnns[imgid]
+    gtbox_and_label_list = []
+    for ann in annotation:
+        box = ann['bbox']
+
+        box = [box[0], box[1], box[0]+box[2], box[1]+box[3]]  # [xmin, ymin, xmax, ymax]
+        cat_id = ann['category_id']
+        cat_name = coco_dict.originID_classes[cat_id] #ID_NAME_DICT[cat_id]
+        label = coco_dict.NAME_LABEL_MAP[cat_name]
+        gtbox_and_label_list.append(box + [label])
+    gtbox_and_label_list = np.array(gtbox_and_label_list, dtype=np.int32)
+    # print (img.shape, gtbox_and_label_list.shape)
+    if gtbox_and_label_list.shape[0] == 0:
+        return next_img(step+1)
+    else:
+        return imgid, img[:, :, ::-1], gtbox_and_label_list
+
+
+if __name__ == '__main__':
+
+    imgid, img,  gtbox = next_img(3234)
+
+    print("::")
+    from libs.box_utils.draw_box_in_img import draw_boxes_with_label_and_scores
+
+    img = draw_boxes_with_label_and_scores(img_array=img, boxes=gtbox[:, :-1], labels=gtbox[:, -1],
+                                           scores=np.ones(shape=(len(gtbox), )))
+    print ("_----")
+
+
+    cv2.imshow("test", img)
+    cv2.waitKey(0)
+
+
diff --git a/example-apps/PDD/pcb-defect-detection/data/pretrained_weights/README.md b/example-apps/PDD/pcb-defect-detection/data/pretrained_weights/README.md
new file mode 100755
index 0000000..f1ae76b
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/data/pretrained_weights/README.md
@@ -0,0 +1 @@
+Please download [resnet50_v1](http://download.tensorflow.org/models/resnet_v1_50_2016_08_28.tar.gz)、[resnet101_v1](http://download.tensorflow.org/models/resnet_v1_101_2016_08_28.tar.gz) pre-trained models on Imagenet, put it to data/pretrained_weights.   
\ No newline at end of file
diff --git a/example-apps/PDD/pcb-defect-detection/data/pretrained_weights/mobilenet/README.md b/example-apps/PDD/pcb-defect-detection/data/pretrained_weights/mobilenet/README.md
new file mode 100755
index 0000000..1158885
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/data/pretrained_weights/mobilenet/README.md
@@ -0,0 +1 @@
+Please download [mobilenet_v2](https://storage.googleapis.com/mobilenet_v2/checkpoints/mobilenet_v2_1.0_224.tgz) pre-trained model on Imagenet, put it to data/pretrained_weights/mobilenet.
\ No newline at end of file
diff --git a/example-apps/PDD/pcb-defect-detection/data/tfrecord/pcb_train.tfrecord_old b/example-apps/PDD/pcb-defect-detection/data/tfrecord/pcb_train.tfrecord_old
new file mode 120000
index 0000000..e981168
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/data/tfrecord/pcb_train.tfrecord_old
@@ -0,0 +1 @@
+/home/gq123/dailinhui/R-FCN_Tensorflow-dlh/data/tfrecord/pascal_train.tfrecord
\ No newline at end of file
diff --git a/example-apps/PDD/pcb-defect-detection/help_utils/__init__.py b/example-apps/PDD/pcb-defect-detection/help_utils/__init__.py
new file mode 100755
index 0000000..e69de29
diff --git a/example-apps/PDD/pcb-defect-detection/help_utils/tools.py b/example-apps/PDD/pcb-defect-detection/help_utils/tools.py
new file mode 100755
index 0000000..8b696c8
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/help_utils/tools.py
@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+from __future__ import division, print_function, absolute_import
+import math
+import sys
+import os
+
+
+def view_bar(message, num, total):
+    rate = num / total
+    rate_num = int(rate * 40)
+    rate_nums = math.ceil(rate * 100)
+    r = '\r%s:[%s%s]%d%%\t%d/%d' % (message, ">" * rate_num, " " * (40 - rate_num), rate_nums, num, total,)
+    sys.stdout.write(r)
+    sys.stdout.flush()
+
+
+def mkdir(path):
+    if not os.path.exists(path):
+        os.makedirs(path)
\ No newline at end of file
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/1/07_open_circuit_01.jpg b/example-apps/PDD/pcb-defect-detection/input_image/1/07_open_circuit_01.jpg
new file mode 100644
index 0000000..a44009e
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/1/07_open_circuit_01.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/1/11_missing_hole_09.jpg b/example-apps/PDD/pcb-defect-detection/input_image/1/11_missing_hole_09.jpg
new file mode 100644
index 0000000..b0161ee
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/1/11_missing_hole_09.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/1/11_short_08.jpg b/example-apps/PDD/pcb-defect-detection/input_image/1/11_short_08.jpg
new file mode 100644
index 0000000..d157e56
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/1/11_short_08.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/2/05_missing_hole_09.jpg b/example-apps/PDD/pcb-defect-detection/input_image/2/05_missing_hole_09.jpg
new file mode 100644
index 0000000..f15204d
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/2/05_missing_hole_09.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/2/11_open_circuit_04.jpg b/example-apps/PDD/pcb-defect-detection/input_image/2/11_open_circuit_04.jpg
new file mode 100644
index 0000000..922e05a
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/2/11_open_circuit_04.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/2/11_short_10.jpg b/example-apps/PDD/pcb-defect-detection/input_image/2/11_short_10.jpg
new file mode 100644
index 0000000..189e2a5
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/2/11_short_10.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/3/01_missing_hole_08.jpg b/example-apps/PDD/pcb-defect-detection/input_image/3/01_missing_hole_08.jpg
new file mode 100644
index 0000000..3ca76e2
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/3/01_missing_hole_08.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/3/07_short_03.jpg b/example-apps/PDD/pcb-defect-detection/input_image/3/07_short_03.jpg
new file mode 100644
index 0000000..3630ce9
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/3/07_short_03.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/3/10_open_circuit_04.jpg b/example-apps/PDD/pcb-defect-detection/input_image/3/10_open_circuit_04.jpg
new file mode 100644
index 0000000..1b22cf5
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/3/10_open_circuit_04.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/4/01_missing_hole_08.jpg b/example-apps/PDD/pcb-defect-detection/input_image/4/01_missing_hole_08.jpg
new file mode 100644
index 0000000..3ca76e2
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/4/01_missing_hole_08.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/4/07_short_03.jpg b/example-apps/PDD/pcb-defect-detection/input_image/4/07_short_03.jpg
new file mode 100644
index 0000000..3630ce9
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/4/07_short_03.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/4/10_open_circuit_04.jpg b/example-apps/PDD/pcb-defect-detection/input_image/4/10_open_circuit_04.jpg
new file mode 100644
index 0000000..1b22cf5
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/4/10_open_circuit_04.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/5/01_missing_hole_08.jpg b/example-apps/PDD/pcb-defect-detection/input_image/5/01_missing_hole_08.jpg
new file mode 100644
index 0000000..3ca76e2
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/5/01_missing_hole_08.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/5/07_short_03.jpg b/example-apps/PDD/pcb-defect-detection/input_image/5/07_short_03.jpg
new file mode 100644
index 0000000..3630ce9
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/5/07_short_03.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/5/10_open_circuit_04.jpg b/example-apps/PDD/pcb-defect-detection/input_image/5/10_open_circuit_04.jpg
new file mode 100644
index 0000000..1b22cf5
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/5/10_open_circuit_04.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/6/01_missing_hole_08.jpg b/example-apps/PDD/pcb-defect-detection/input_image/6/01_missing_hole_08.jpg
new file mode 100644
index 0000000..3ca76e2
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/6/01_missing_hole_08.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/6/07_short_03.jpg b/example-apps/PDD/pcb-defect-detection/input_image/6/07_short_03.jpg
new file mode 100644
index 0000000..3630ce9
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/6/07_short_03.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/6/10_open_circuit_04.jpg b/example-apps/PDD/pcb-defect-detection/input_image/6/10_open_circuit_04.jpg
new file mode 100644
index 0000000..1b22cf5
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/6/10_open_circuit_04.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/7/01_missing_hole_08.jpg b/example-apps/PDD/pcb-defect-detection/input_image/7/01_missing_hole_08.jpg
new file mode 100644
index 0000000..3ca76e2
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/7/01_missing_hole_08.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/7/07_short_03.jpg b/example-apps/PDD/pcb-defect-detection/input_image/7/07_short_03.jpg
new file mode 100644
index 0000000..3630ce9
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/7/07_short_03.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/7/10_open_circuit_04.jpg b/example-apps/PDD/pcb-defect-detection/input_image/7/10_open_circuit_04.jpg
new file mode 100644
index 0000000..1b22cf5
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/7/10_open_circuit_04.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/8/01_missing_hole_08.jpg b/example-apps/PDD/pcb-defect-detection/input_image/8/01_missing_hole_08.jpg
new file mode 100644
index 0000000..3ca76e2
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/8/01_missing_hole_08.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/8/07_short_03.jpg b/example-apps/PDD/pcb-defect-detection/input_image/8/07_short_03.jpg
new file mode 100644
index 0000000..3630ce9
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/8/07_short_03.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/8/10_open_circuit_04.jpg b/example-apps/PDD/pcb-defect-detection/input_image/8/10_open_circuit_04.jpg
new file mode 100644
index 0000000..1b22cf5
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/8/10_open_circuit_04.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/9/01_missing_hole_08.jpg b/example-apps/PDD/pcb-defect-detection/input_image/9/01_missing_hole_08.jpg
new file mode 100644
index 0000000..3ca76e2
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/9/01_missing_hole_08.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/9/07_short_03.jpg b/example-apps/PDD/pcb-defect-detection/input_image/9/07_short_03.jpg
new file mode 100644
index 0000000..3630ce9
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/9/07_short_03.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/input_image/9/10_open_circuit_04.jpg b/example-apps/PDD/pcb-defect-detection/input_image/9/10_open_circuit_04.jpg
new file mode 100644
index 0000000..1b22cf5
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/input_image/9/10_open_circuit_04.jpg differ
diff --git a/example-apps/PDD/pcb-defect-detection/libs/__init__.py b/example-apps/PDD/pcb-defect-detection/libs/__init__.py
new file mode 100755
index 0000000..e69de29
diff --git a/example-apps/PDD/pcb-defect-detection/libs/__init__.pyc b/example-apps/PDD/pcb-defect-detection/libs/__init__.pyc
new file mode 100755
index 0000000..83a347d
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/libs/__init__.pyc differ
diff --git a/example-apps/PDD/pcb-defect-detection/libs/box_utils/__init__.py b/example-apps/PDD/pcb-defect-detection/libs/box_utils/__init__.py
new file mode 100755
index 0000000..e69de29
diff --git a/example-apps/PDD/pcb-defect-detection/libs/box_utils/anchor_utils.py b/example-apps/PDD/pcb-defect-detection/libs/box_utils/anchor_utils.py
new file mode 100755
index 0000000..d01c54b
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/box_utils/anchor_utils.py
@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import, print_function, division
+
+import tensorflow as tf
+from libs.configs import cfgs
+
+
+def make_anchors(base_anchor_size, anchor_scales, anchor_ratios,
+                 featuremap_height, featuremap_width,
+                 stride, name='make_anchors'):
+    '''
+    :param base_anchor_size:256
+    :param anchor_scales:
+    :param anchor_ratios:
+    :param featuremap_height:
+    :param featuremap_width:
+    :param stride:
+    :return:
+    '''
+    with tf.variable_scope(name):
+        base_anchor = tf.constant([0, 0, base_anchor_size, base_anchor_size], tf.float32)  # [x_center, y_center, w, h]
+
+        ws, hs = enum_ratios(enum_scales(base_anchor, anchor_scales),
+                             anchor_ratios)  # per locations ws and hs
+
+        # featuremap_height = tf.Print(featuremap_height,
+        #                              [featuremap_height, featuremap_width], summarize=10,
+        #                              message=name+"_SHAPE***")
+
+        x_centers = tf.range(featuremap_width, dtype=tf.float32) * stride
+        y_centers = tf.range(featuremap_height, dtype=tf.float32) * stride
+
+        if cfgs.USE_CENTER_OFFSET:
+            x_centers = x_centers + stride/2.
+            y_centers = y_centers + stride/2.
+
+        x_centers, y_centers = tf.meshgrid(x_centers, y_centers)
+
+        ws, x_centers = tf.meshgrid(ws, x_centers)
+        hs, y_centers = tf.meshgrid(hs, y_centers)
+
+        anchor_centers = tf.stack([x_centers, y_centers], 2)
+        anchor_centers = tf.reshape(anchor_centers, [-1, 2])
+
+        box_sizes = tf.stack([ws, hs], axis=2)
+        box_sizes = tf.reshape(box_sizes, [-1, 2])
+        # anchors = tf.concat([anchor_centers, box_sizes], axis=1)
+        anchors = tf.concat([anchor_centers - 0.5*box_sizes,
+                             anchor_centers + 0.5*box_sizes], axis=1)
+        return anchors
+
+
+def enum_scales(base_anchor, anchor_scales):
+
+    anchor_scales = base_anchor * tf.constant(anchor_scales, dtype=tf.float32, shape=(len(anchor_scales), 1))
+
+    return anchor_scales
+
+
+def enum_ratios(anchors, anchor_ratios):
+    '''
+    ratio = h /w
+    :param anchors:
+    :param anchor_ratios:
+    :return:
+    '''
+    ws = anchors[:, 2]  # for base anchor: w == h
+    hs = anchors[:, 3]
+    sqrt_ratios = tf.sqrt(tf.constant(anchor_ratios))
+
+    ws = tf.reshape(ws / sqrt_ratios[:, tf.newaxis], [-1, 1])
+    hs = tf.reshape(hs * sqrt_ratios[:, tf.newaxis], [-1, 1])
+
+    return hs, ws
+
+
+if __name__ == '__main__':
+    import os
+    os.environ["CUDA_VISIBLE_DEVICES"] = '0'
+    base_anchor_size = 256
+    anchor_scales = [1.0]
+    anchor_ratios = [0.5, 2.0, 1.0]
+    anchors = make_anchors(base_anchor_size=base_anchor_size, anchor_ratios=anchor_ratios,
+                           anchor_scales=anchor_scales,
+                           featuremap_width=32,
+                           featuremap_height=63,
+                           stride=16)
+    init = tf.global_variables_initializer()
+    with tf.Session() as sess:
+        sess.run(init)
+        anchor_result = sess.run(anchors)
+        print (anchor_result.shape)
diff --git a/example-apps/PDD/pcb-defect-detection/libs/box_utils/boxes_utils.py b/example-apps/PDD/pcb-defect-detection/libs/box_utils/boxes_utils.py
new file mode 100755
index 0000000..8f4b5a3
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/box_utils/boxes_utils.py
@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf
+
+def ious_calu(boxes_1, boxes_2):
+    '''
+
+    :param boxes_1: [N, 4] [xmin, ymin, xmax, ymax]
+    :param boxes_2: [M, 4] [xmin, ymin. xmax, ymax]
+    :return:
+    '''
+    boxes_1 = tf.cast(boxes_1, tf.float32)
+    boxes_2 = tf.cast(boxes_2, tf.float32)
+    xmin_1, ymin_1, xmax_1, ymax_1 = tf.split(boxes_1, 4, axis=1)  # xmin_1 shape is [N, 1]..
+    xmin_2, ymin_2, xmax_2, ymax_2 = tf.unstack(boxes_2, axis=1)  # xmin_2 shape is [M, ]..
+
+    max_xmin = tf.maximum(xmin_1, xmin_2)
+    min_xmax = tf.minimum(xmax_1, xmax_2)
+
+    max_ymin = tf.maximum(ymin_1, ymin_2)
+    min_ymax = tf.minimum(ymax_1, ymax_2)
+
+    overlap_h = tf.maximum(0., min_ymax - max_ymin)  # avoid h < 0
+    overlap_w = tf.maximum(0., min_xmax - max_xmin)
+
+    overlaps = overlap_h * overlap_w
+
+    area_1 = (xmax_1 - xmin_1) * (ymax_1 - ymin_1)  # [N, 1]
+    area_2 = (xmax_2 - xmin_2) * (ymax_2 - ymin_2)  # [M, ]
+
+    ious = overlaps / (area_1 + area_2 - overlaps)
+
+    return ious
+
+
+def clip_boxes_to_img_boundaries(decode_boxes, img_shape):
+    '''
+
+    :param decode_boxes:
+    :return: decode boxes, and already clip to boundaries
+    '''
+
+    with tf.name_scope('clip_boxes_to_img_boundaries'):
+
+        # xmin, ymin, xmax, ymax = tf.unstack(decode_boxes, axis=1)
+        xmin = decode_boxes[:, 0]
+        ymin = decode_boxes[:, 1]
+        xmax = decode_boxes[:, 2]
+        ymax = decode_boxes[:, 3]
+        img_h, img_w = img_shape[1], img_shape[2]
+
+        img_h, img_w = tf.cast(img_h, tf.float32), tf.cast(img_w, tf.float32)
+
+        # xmin = tf.maximum(tf.minimum(xmin, img_w-1.), 0.)
+        # ymin = tf.maximum(tf.minimum(ymin, img_h-1.), 0.)
+
+        # xmax = tf.maximum(tf.minimum(xmax, img_w-1.), 0.)
+        # ymax = tf.maximum(tf.minimum(ymax, img_h-1.), 0.)
+        xmin = tf.maximum(tf.minimum(xmin, img_w), 0.)
+        ymin = tf.maximum(tf.minimum(ymin, img_h), 0.)
+
+        xmax = tf.maximum(tf.minimum(xmax, img_w), 0.)
+        ymax = tf.maximum(tf.minimum(ymax, img_h), 0.)
+
+        return tf.transpose(tf.stack([xmin, ymin, xmax, ymax]))
+
+
+def filter_outside_boxes(boxes, img_h, img_w):
+    '''
+    :param anchors:boxes with format [xmin, ymin, xmax, ymax]
+    :param img_h: height of image
+    :param img_w: width of image
+    :return: indices of anchors that inside the image boundary
+    '''
+
+    with tf.name_scope('filter_outside_boxes'):
+        xmin, ymin, xmax, ymax = tf.unstack(boxes, axis=1)
+
+        xmin_index = tf.greater_equal(xmin, 0)
+        ymin_index = tf.greater_equal(ymin, 0)
+        xmax_index = tf.less_equal(xmax, tf.cast(img_w, tf.float32))
+        ymax_index = tf.less_equal(ymax, tf.cast(img_h, tf.float32))
+
+        indices = tf.transpose(tf.stack([xmin_index, ymin_index, xmax_index, ymax_index]))
+        indices = tf.cast(indices, dtype=tf.int32)
+        indices = tf.reduce_sum(indices, axis=1)
+        indices = tf.where(tf.equal(indices, 4))
+        # indices = tf.equal(indices, 4)
+        return tf.reshape(indices, [-1])
+
+
+def padd_boxes_with_zeros(boxes, scores, max_num_of_boxes):
+
+    '''
+    num of boxes less than max num of boxes, so it need to pad with zeros[0, 0, 0, 0]
+    :param boxes:
+    :param scores: [-1]
+    :param max_num_of_boxes:
+    :return:
+    '''
+
+    pad_num = tf.cast(max_num_of_boxes, tf.int32) - tf.shape(boxes)[0]
+
+    zero_boxes = tf.zeros(shape=[pad_num, 4], dtype=boxes.dtype)
+    zero_scores = tf.zeros(shape=[pad_num], dtype=scores.dtype)
+
+    final_boxes = tf.concat([boxes, zero_boxes], axis=0)
+
+    final_scores = tf.concat([scores, zero_scores], axis=0)
+
+    return final_boxes, final_scores
\ No newline at end of file
diff --git a/example-apps/PDD/pcb-defect-detection/libs/box_utils/boxes_utils_backup.py b/example-apps/PDD/pcb-defect-detection/libs/box_utils/boxes_utils_backup.py
new file mode 100755
index 0000000..e9b1885
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/box_utils/boxes_utils_backup.py
@@ -0,0 +1,110 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf
+
+def ious_calu(boxes_1, boxes_2):
+    '''
+
+    :param boxes_1: [N, 4] [xmin, ymin, xmax, ymax]
+    :param boxes_2: [M, 4] [xmin, ymin. xmax, ymax]
+    :return:
+    '''
+    boxes_1 = tf.cast(boxes_1, tf.float32)
+    boxes_2 = tf.cast(boxes_2, tf.float32)
+    xmin_1, ymin_1, xmax_1, ymax_1 = tf.split(boxes_1, 4, axis=1)  # xmin_1 shape is [N, 1]..
+    xmin_2, ymin_2, xmax_2, ymax_2 = tf.unstack(boxes_2, axis=1)  # xmin_2 shape is [M, ]..
+
+    max_xmin = tf.maximum(xmin_1, xmin_2)
+    min_xmax = tf.minimum(xmax_1, xmax_2)
+
+    max_ymin = tf.maximum(ymin_1, ymin_2)
+    min_ymax = tf.minimum(ymax_1, ymax_2)
+
+    overlap_h = tf.maximum(0., min_ymax - max_ymin)  # avoid h < 0
+    overlap_w = tf.maximum(0., min_xmax - max_xmin)
+
+    overlaps = overlap_h * overlap_w
+
+    area_1 = (xmax_1 - xmin_1) * (ymax_1 - ymin_1)  # [N, 1]
+    area_2 = (xmax_2 - xmin_2) * (ymax_2 - ymin_2)  # [M, ]
+
+    ious = overlaps / (area_1 + area_2 - overlaps)
+
+    return ious
+
+
+def clip_boxes_to_img_boundaries(decode_boxes, img_shape):
+    '''
+
+    :param decode_boxes:
+    :return: decode boxes, and already clip to boundaries
+    '''
+
+    with tf.name_scope('clip_boxes_to_img_boundaries'):
+
+        # xmin, ymin, xmax, ymax = tf.unstack(decode_boxes, axis=1)
+        xmin = decode_boxes[:, 0]
+        ymin = decode_boxes[:, 1]
+        xmax = decode_boxes[:, 2]
+        ymax = decode_boxes[:, 3]
+        img_h, img_w = img_shape[1], img_shape[2]
+
+        img_h, img_w = tf.cast(img_h, tf.float32), tf.cast(img_w, tf.float32)
+
+        xmin = tf.maximum(tf.minimum(xmin, img_w-1.), 0.)
+        ymin = tf.maximum(tf.minimum(ymin, img_h-1.), 0.)
+
+        xmax = tf.maximum(tf.minimum(xmax, img_w-1.), 0.)
+        ymax = tf.maximum(tf.minimum(ymax, img_h-1.), 0.)
+
+        return tf.transpose(tf.stack([xmin, ymin, xmax, ymax]))
+
+
+def filter_outside_boxes(boxes, img_h, img_w):
+    '''
+    :param anchors:boxes with format [xmin, ymin, xmax, ymax]
+    :param img_h: height of image
+    :param img_w: width of image
+    :return: indices of anchors that inside the image boundary
+    '''
+
+    with tf.name_scope('filter_outside_boxes'):
+        xmin, ymin, xmax, ymax = tf.unstack(boxes, axis=1)
+
+        xmin_index = tf.greater_equal(xmin, 0)
+        ymin_index = tf.greater_equal(ymin, 0)
+        xmax_index = tf.less_equal(xmax, tf.cast(img_w, tf.float32))
+        ymax_index = tf.less_equal(ymax, tf.cast(img_h, tf.float32))
+
+        indices = tf.transpose(tf.stack([xmin_index, ymin_index, xmax_index, ymax_index]))
+        indices = tf.cast(indices, dtype=tf.int32)
+        indices = tf.reduce_sum(indices, axis=1)
+        indices = tf.where(tf.equal(indices, 4))
+        # indices = tf.equal(indices, 4)
+        return tf.reshape(indices, [-1])
+
+
+def padd_boxes_with_zeros(boxes, scores, max_num_of_boxes):
+
+    '''
+    num of boxes less than max num of boxes, so it need to pad with zeros[0, 0, 0, 0]
+    :param boxes:
+    :param scores: [-1]
+    :param max_num_of_boxes:
+    :return:
+    '''
+
+    pad_num = tf.cast(max_num_of_boxes, tf.int32) - tf.shape(boxes)[0]
+
+    zero_boxes = tf.zeros(shape=[pad_num, 4], dtype=boxes.dtype)
+    zero_scores = tf.zeros(shape=[pad_num], dtype=scores.dtype)
+
+    final_boxes = tf.concat([boxes, zero_boxes], axis=0)
+
+    final_scores = tf.concat([scores, zero_scores], axis=0)
+
+    return final_boxes, final_scores
\ No newline at end of file
diff --git a/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/Makefile b/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/Makefile
new file mode 100755
index 0000000..1e9e686
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/Makefile
@@ -0,0 +1,6 @@
+all:
+	python setup.py build_ext --inplace
+	rm -rf build
+clean:
+	rm -rf */*.pyc
+	rm -rf */*.so
diff --git a/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/__init__.py b/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/__init__.py
new file mode 100755
index 0000000..e69de29
diff --git a/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/bbox.c b/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/bbox.c
new file mode 100755
index 0000000..747f59d
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/bbox.c
@@ -0,0 +1,11128 @@
+/* Generated by Cython 0.25.2 */
+
+#define PY_SSIZE_T_CLEAN
+#include "Python.h"
+#ifndef Py_PYTHON_H
+    #error Python headers needed to compile C extensions, please install development version of Python.
+#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000)
+    #error Cython requires Python 2.6+ or Python 3.2+.
+#else
+#define CYTHON_ABI "0_25_2"
+#include <stddef.h>
+#ifndef offsetof
+  #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
+#endif
+#if !defined(WIN32) && !defined(MS_WINDOWS)
+  #ifndef __stdcall
+    #define __stdcall
+  #endif
+  #ifndef __cdecl
+    #define __cdecl
+  #endif
+  #ifndef __fastcall
+    #define __fastcall
+  #endif
+#endif
+#ifndef DL_IMPORT
+  #define DL_IMPORT(t) t
+#endif
+#ifndef DL_EXPORT
+  #define DL_EXPORT(t) t
+#endif
+#ifndef HAVE_LONG_LONG
+  #if PY_VERSION_HEX >= 0x03030000 || (PY_MAJOR_VERSION == 2 && PY_VERSION_HEX >= 0x02070000)
+    #define HAVE_LONG_LONG
+  #endif
+#endif
+#ifndef PY_LONG_LONG
+  #define PY_LONG_LONG LONG_LONG
+#endif
+#ifndef Py_HUGE_VAL
+  #define Py_HUGE_VAL HUGE_VAL
+#endif
+#ifdef PYPY_VERSION
+  #define CYTHON_COMPILING_IN_PYPY 1
+  #define CYTHON_COMPILING_IN_PYSTON 0
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_ASYNC_SLOTS
+  #define CYTHON_USE_ASYNC_SLOTS 0
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #undef CYTHON_AVOID_BORROWED_REFS
+  #define CYTHON_AVOID_BORROWED_REFS 1
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+#elif defined(PYSTON_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_PYSTON 1
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #ifndef CYTHON_USE_TYPE_SLOTS
+    #define CYTHON_USE_TYPE_SLOTS 1
+  #endif
+  #undef CYTHON_USE_ASYNC_SLOTS
+  #define CYTHON_USE_ASYNC_SLOTS 0
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #ifndef CYTHON_USE_UNICODE_INTERNALS
+    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #endif
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #ifndef CYTHON_AVOID_BORROWED_REFS
+    #define CYTHON_AVOID_BORROWED_REFS 0
+  #endif
+  #ifndef CYTHON_ASSUME_SAFE_MACROS
+    #define CYTHON_ASSUME_SAFE_MACROS 1
+  #endif
+  #ifndef CYTHON_UNPACK_METHODS
+    #define CYTHON_UNPACK_METHODS 1
+  #endif
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+#else
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_PYSTON 0
+  #define CYTHON_COMPILING_IN_CPYTHON 1
+  #ifndef CYTHON_USE_TYPE_SLOTS
+    #define CYTHON_USE_TYPE_SLOTS 1
+  #endif
+  #if PY_MAJOR_VERSION < 3
+    #undef CYTHON_USE_ASYNC_SLOTS
+    #define CYTHON_USE_ASYNC_SLOTS 0
+  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+    #define CYTHON_USE_ASYNC_SLOTS 1
+  #endif
+  #if PY_VERSION_HEX < 0x02070000
+    #undef CYTHON_USE_PYLONG_INTERNALS
+    #define CYTHON_USE_PYLONG_INTERNALS 0
+  #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
+    #define CYTHON_USE_PYLONG_INTERNALS 1
+  #endif
+  #ifndef CYTHON_USE_PYLIST_INTERNALS
+    #define CYTHON_USE_PYLIST_INTERNALS 1
+  #endif
+  #ifndef CYTHON_USE_UNICODE_INTERNALS
+    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #endif
+  #if PY_VERSION_HEX < 0x030300F0
+    #undef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
+  #elif !defined(CYTHON_USE_UNICODE_WRITER)
+    #define CYTHON_USE_UNICODE_WRITER 1
+  #endif
+  #ifndef CYTHON_AVOID_BORROWED_REFS
+    #define CYTHON_AVOID_BORROWED_REFS 0
+  #endif
+  #ifndef CYTHON_ASSUME_SAFE_MACROS
+    #define CYTHON_ASSUME_SAFE_MACROS 1
+  #endif
+  #ifndef CYTHON_UNPACK_METHODS
+    #define CYTHON_UNPACK_METHODS 1
+  #endif
+  #ifndef CYTHON_FAST_THREAD_STATE
+    #define CYTHON_FAST_THREAD_STATE 1
+  #endif
+  #ifndef CYTHON_FAST_PYCALL
+    #define CYTHON_FAST_PYCALL 1
+  #endif
+#endif
+#if !defined(CYTHON_FAST_PYCCALL)
+#define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
+#endif
+#if CYTHON_USE_PYLONG_INTERNALS
+  #include "longintrepr.h"
+  #undef SHIFT
+  #undef BASE
+  #undef MASK
+#endif
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
+  #define Py_OptimizeFlag 0
+#endif
+#define __PYX_BUILD_PY_SSIZE_T "n"
+#define CYTHON_FORMAT_SSIZE_T "z"
+#if PY_MAJOR_VERSION < 3
+  #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
+  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+  #define __Pyx_DefaultClassType PyClass_Type
+#else
+  #define __Pyx_BUILTIN_MODULE_NAME "builtins"
+  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+  #define __Pyx_DefaultClassType PyType_Type
+#endif
+#ifndef Py_TPFLAGS_CHECKTYPES
+  #define Py_TPFLAGS_CHECKTYPES 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_INDEX
+  #define Py_TPFLAGS_HAVE_INDEX 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
+  #define Py_TPFLAGS_HAVE_NEWBUFFER 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_FINALIZE
+  #define Py_TPFLAGS_HAVE_FINALIZE 0
+#endif
+#ifndef METH_FASTCALL
+  #define METH_FASTCALL 0x80
+  typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject **args,
+                                              Py_ssize_t nargs, PyObject *kwnames);
+#else
+  #define __Pyx_PyCFunctionFast _PyCFunctionFast
+#endif
+#if CYTHON_FAST_PYCCALL
+#define __Pyx_PyFastCFunction_Check(func)\
+    ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST)))))
+#else
+#define __Pyx_PyFastCFunction_Check(func) 0
+#endif
+#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+  #define CYTHON_PEP393_ENABLED 1
+  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
+                                              0 : _PyUnicode_Ready((PyObject *)(op)))
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
+  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
+  #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
+  #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, ch)
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+#else
+  #define CYTHON_PEP393_ENABLED 0
+  #define PyUnicode_1BYTE_KIND  1
+  #define PyUnicode_2BYTE_KIND  2
+  #define PyUnicode_4BYTE_KIND  4
+  #define __Pyx_PyUnicode_READY(op)       (0)
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
+  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
+  #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
+  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
+#endif
+#if CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyUnicode_Concat(a, b)      PyNumber_Add(a, b)
+  #define __Pyx_PyUnicode_ConcatSafe(a, b)  PyNumber_Add(a, b)
+#else
+  #define __Pyx_PyUnicode_Concat(a, b)      PyUnicode_Concat(a, b)
+  #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
+      PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
+  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
+  #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
+  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
+  #define PyObject_Malloc(s)   PyMem_Malloc(s)
+  #define PyObject_Free(p)     PyMem_Free(p)
+  #define PyObject_Realloc(p)  PyMem_Realloc(p)
+#endif
+#if CYTHON_COMPILING_IN_PYSTON
+  #define __Pyx_PyCode_HasFreeVars(co)  PyCode_HasFreeVars(co)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
+#else
+  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
+#endif
+#define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
+#define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyString_Format(a, b)  PyUnicode_Format(a, b)
+#else
+  #define __Pyx_PyString_Format(a, b)  PyString_Format(a, b)
+#endif
+#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)
+  #define PyObject_ASCII(o)            PyObject_Repr(o)
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define PyBaseString_Type            PyUnicode_Type
+  #define PyStringObject               PyUnicodeObject
+  #define PyString_Type                PyUnicode_Type
+  #define PyString_Check               PyUnicode_Check
+  #define PyString_CheckExact          PyUnicode_CheckExact
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)
+  #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)
+#else
+  #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
+  #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
+#endif
+#ifndef PySet_CheckExact
+  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
+#endif
+#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
+#if PY_MAJOR_VERSION >= 3
+  #define PyIntObject                  PyLongObject
+  #define PyInt_Type                   PyLong_Type
+  #define PyInt_Check(op)              PyLong_Check(op)
+  #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
+  #define PyInt_FromString             PyLong_FromString
+  #define PyInt_FromUnicode            PyLong_FromUnicode
+  #define PyInt_FromLong               PyLong_FromLong
+  #define PyInt_FromSize_t             PyLong_FromSize_t
+  #define PyInt_FromSsize_t            PyLong_FromSsize_t
+  #define PyInt_AsLong                 PyLong_AsLong
+  #define PyInt_AS_LONG                PyLong_AS_LONG
+  #define PyInt_AsSsize_t              PyLong_AsSsize_t
+  #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
+  #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
+  #define PyNumber_Int                 PyNumber_Long
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define PyBoolObject                 PyLongObject
+#endif
+#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY
+  #ifndef PyUnicode_InternFromString
+    #define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
+  #endif
+#endif
+#if PY_VERSION_HEX < 0x030200A4
+  typedef long Py_hash_t;
+  #define __Pyx_PyInt_FromHash_t PyInt_FromLong
+  #define __Pyx_PyInt_AsHash_t   PyInt_AsLong
+#else
+  #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
+  #define __Pyx_PyInt_AsHash_t   PyInt_AsSsize_t
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func))
+#else
+  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
+#endif
+#if CYTHON_USE_ASYNC_SLOTS
+  #if PY_VERSION_HEX >= 0x030500B1
+    #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
+    #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async)
+  #else
+    typedef struct {
+        unaryfunc am_await;
+        unaryfunc am_aiter;
+        unaryfunc am_anext;
+    } __Pyx_PyAsyncMethodsStruct;
+    #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))
+  #endif
+#else
+  #define __Pyx_PyType_AsAsync(obj) NULL
+#endif
+#ifndef CYTHON_RESTRICT
+  #if defined(__GNUC__)
+    #define CYTHON_RESTRICT __restrict__
+  #elif defined(_MSC_VER) && _MSC_VER >= 1400
+    #define CYTHON_RESTRICT __restrict
+  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define CYTHON_RESTRICT restrict
+  #else
+    #define CYTHON_RESTRICT
+  #endif
+#endif
+#ifndef CYTHON_UNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define CYTHON_UNUSED __attribute__ ((__unused__))
+#   else
+#     define CYTHON_UNUSED
+#   endif
+# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))
+#   define CYTHON_UNUSED __attribute__ ((__unused__))
+# else
+#   define CYTHON_UNUSED
+# endif
+#endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+#  if defined(__cplusplus)
+     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+#  else
+#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+#  endif
+#endif
+#ifndef CYTHON_NCP_UNUSED
+# if CYTHON_COMPILING_IN_CPYTHON
+#  define CYTHON_NCP_UNUSED
+# else
+#  define CYTHON_NCP_UNUSED CYTHON_UNUSED
+# endif
+#endif
+#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
+
+#ifndef CYTHON_INLINE
+  #if defined(__clang__)
+    #define CYTHON_INLINE __inline__ __attribute__ ((__unused__))
+  #elif defined(__GNUC__)
+    #define CYTHON_INLINE __inline__
+  #elif defined(_MSC_VER)
+    #define CYTHON_INLINE __inline
+  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define CYTHON_INLINE inline
+  #else
+    #define CYTHON_INLINE
+  #endif
+#endif
+
+#if defined(WIN32) || defined(MS_WINDOWS)
+  #define _USE_MATH_DEFINES
+#endif
+#include <math.h>
+#ifdef NAN
+#define __PYX_NAN() ((float) NAN)
+#else
+static CYTHON_INLINE float __PYX_NAN() {
+  float value;
+  memset(&value, 0xFF, sizeof(value));
+  return value;
+}
+#endif
+#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL)
+#define __Pyx_truncl trunc
+#else
+#define __Pyx_truncl truncl
+#endif
+
+
+#define __PYX_ERR(f_index, lineno, Ln_error) \
+{ \
+  __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \
+}
+
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_TrueDivide(x,y)
+  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceTrueDivide(x,y)
+#else
+  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
+  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
+#endif
+
+#ifndef __PYX_EXTERN_C
+  #ifdef __cplusplus
+    #define __PYX_EXTERN_C extern "C"
+  #else
+    #define __PYX_EXTERN_C extern
+  #endif
+#endif
+
+#define __PYX_HAVE__cython_bbox
+#define __PYX_HAVE_API__cython_bbox
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "numpy/arrayobject.h"
+#include "numpy/ufuncobject.h"
+#ifdef _OPENMP
+#include <omp.h>
+#endif /* _OPENMP */
+
+#ifdef PYREX_WITHOUT_ASSERTIONS
+#define CYTHON_WITHOUT_ASSERTIONS
+#endif
+
+typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding;
+                const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;
+
+#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0
+#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0
+#define __PYX_DEFAULT_STRING_ENCODING ""
+#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString
+#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
+#define __Pyx_uchar_cast(c) ((unsigned char)c)
+#define __Pyx_long_cast(x) ((long)x)
+#define __Pyx_fits_Py_ssize_t(v, type, is_signed)  (\
+    (sizeof(type) < sizeof(Py_ssize_t))  ||\
+    (sizeof(type) > sizeof(Py_ssize_t) &&\
+          likely(v < (type)PY_SSIZE_T_MAX ||\
+                 v == (type)PY_SSIZE_T_MAX)  &&\
+          (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\
+                                v == (type)PY_SSIZE_T_MIN)))  ||\
+    (sizeof(type) == sizeof(Py_ssize_t) &&\
+          (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\
+                               v == (type)PY_SSIZE_T_MAX)))  )
+#if defined (__cplusplus) && __cplusplus >= 201103L
+    #include <cstdlib>
+    #define __Pyx_sst_abs(value) std::abs(value)
+#elif SIZEOF_INT >= SIZEOF_SIZE_T
+    #define __Pyx_sst_abs(value) abs(value)
+#elif SIZEOF_LONG >= SIZEOF_SIZE_T
+    #define __Pyx_sst_abs(value) labs(value)
+#elif defined (_MSC_VER) && defined (_M_X64)
+    #define __Pyx_sst_abs(value) _abs64(value)
+#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define __Pyx_sst_abs(value) llabs(value)
+#elif defined (__GNUC__)
+    #define __Pyx_sst_abs(value) __builtin_llabs(value)
+#else
+    #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
+#endif
+static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*);
+static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
+#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
+#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
+#define __Pyx_PyBytes_FromString        PyBytes_FromString
+#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
+#if PY_MAJOR_VERSION < 3
+    #define __Pyx_PyStr_FromString        __Pyx_PyBytes_FromString
+    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
+#else
+    #define __Pyx_PyStr_FromString        __Pyx_PyUnicode_FromString
+    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize
+#endif
+#define __Pyx_PyObject_AsSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
+#define __Pyx_PyBytes_FromCString(s)   __Pyx_PyBytes_FromString((const char*)s)
+#define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
+#define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
+#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
+#if PY_MAJOR_VERSION < 3
+static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u)
+{
+    const Py_UNICODE *u_end = u;
+    while (*u_end++) ;
+    return (size_t)(u_end - u - 1);
+}
+#else
+#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen
+#endif
+#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
+#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
+#define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
+#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
+#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
+#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False))
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
+#if CYTHON_ASSUME_SAFE_MACROS
+#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
+#else
+#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
+#endif
+#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))
+#if PY_MAJOR_VERSION >= 3
+#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))
+#else
+#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
+#endif
+#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+static int __Pyx_sys_getdefaultencoding_not_ascii;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+    PyObject* sys;
+    PyObject* default_encoding = NULL;
+    PyObject* ascii_chars_u = NULL;
+    PyObject* ascii_chars_b = NULL;
+    const char* default_encoding_c;
+    sys = PyImport_ImportModule("sys");
+    if (!sys) goto bad;
+    default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL);
+    Py_DECREF(sys);
+    if (!default_encoding) goto bad;
+    default_encoding_c = PyBytes_AsString(default_encoding);
+    if (!default_encoding_c) goto bad;
+    if (strcmp(default_encoding_c, "ascii") == 0) {
+        __Pyx_sys_getdefaultencoding_not_ascii = 0;
+    } else {
+        char ascii_chars[128];
+        int c;
+        for (c = 0; c < 128; c++) {
+            ascii_chars[c] = c;
+        }
+        __Pyx_sys_getdefaultencoding_not_ascii = 1;
+        ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
+        if (!ascii_chars_u) goto bad;
+        ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);
+        if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) {
+            PyErr_Format(
+                PyExc_ValueError,
+                "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.",
+                default_encoding_c);
+            goto bad;
+        }
+        Py_DECREF(ascii_chars_u);
+        Py_DECREF(ascii_chars_b);
+    }
+    Py_DECREF(default_encoding);
+    return 0;
+bad:
+    Py_XDECREF(default_encoding);
+    Py_XDECREF(ascii_chars_u);
+    Py_XDECREF(ascii_chars_b);
+    return -1;
+}
+#endif
+#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3
+#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
+#else
+#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
+#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+static char* __PYX_DEFAULT_STRING_ENCODING;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+    PyObject* sys;
+    PyObject* default_encoding = NULL;
+    char* default_encoding_c;
+    sys = PyImport_ImportModule("sys");
+    if (!sys) goto bad;
+    default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL);
+    Py_DECREF(sys);
+    if (!default_encoding) goto bad;
+    default_encoding_c = PyBytes_AsString(default_encoding);
+    if (!default_encoding_c) goto bad;
+    __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c));
+    if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;
+    strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);
+    Py_DECREF(default_encoding);
+    return 0;
+bad:
+    Py_XDECREF(default_encoding);
+    return -1;
+}
+#endif
+#endif
+
+
+/* Test for GCC > 2.95 */
+#if defined(__GNUC__)     && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
+  #define likely(x)   __builtin_expect(!!(x), 1)
+  #define unlikely(x) __builtin_expect(!!(x), 0)
+#else /* !__GNUC__ or GCC < 2.95 */
+  #define likely(x)   (x)
+  #define unlikely(x) (x)
+#endif /* __GNUC__ */
+
+static PyObject *__pyx_m;
+static PyObject *__pyx_d;
+static PyObject *__pyx_b;
+static PyObject *__pyx_empty_tuple;
+static PyObject *__pyx_empty_bytes;
+static PyObject *__pyx_empty_unicode;
+static int __pyx_lineno;
+static int __pyx_clineno = 0;
+static const char * __pyx_cfilenm= __FILE__;
+static const char *__pyx_filename;
+
+/* Header.proto */
+#if !defined(CYTHON_CCOMPLEX)
+  #if defined(__cplusplus)
+    #define CYTHON_CCOMPLEX 1
+  #elif defined(_Complex_I)
+    #define CYTHON_CCOMPLEX 1
+  #else
+    #define CYTHON_CCOMPLEX 0
+  #endif
+#endif
+#if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    #include <complex>
+  #else
+    #include <complex.h>
+  #endif
+#endif
+#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__)
+  #undef _Complex_I
+  #define _Complex_I 1.0fj
+#endif
+
+
+static const char *__pyx_f[] = {
+  "_utils/bbox.pyx",
+  "__init__.pxd",
+  "type.pxd",
+};
+/* BufferFormatStructs.proto */
+#define IS_UNSIGNED(type) (((type) -1) > 0)
+struct __Pyx_StructField_;
+#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0)
+typedef struct {
+  const char* name;
+  struct __Pyx_StructField_* fields;
+  size_t size;
+  size_t arraysize[8];
+  int ndim;
+  char typegroup;
+  char is_unsigned;
+  int flags;
+} __Pyx_TypeInfo;
+typedef struct __Pyx_StructField_ {
+  __Pyx_TypeInfo* type;
+  const char* name;
+  size_t offset;
+} __Pyx_StructField;
+typedef struct {
+  __Pyx_StructField* field;
+  size_t parent_offset;
+} __Pyx_BufFmt_StackElem;
+typedef struct {
+  __Pyx_StructField root;
+  __Pyx_BufFmt_StackElem* head;
+  size_t fmt_offset;
+  size_t new_count, enc_count;
+  size_t struct_alignment;
+  int is_complex;
+  char enc_type;
+  char new_packmode;
+  char enc_packmode;
+  char is_valid_array;
+} __Pyx_BufFmt_Context;
+
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":725
+ * # in Cython to enable them only on the right systems.
+ * 
+ * ctypedef npy_int8       int8_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_int16      int16_t
+ * ctypedef npy_int32      int32_t
+ */
+typedef npy_int8 __pyx_t_5numpy_int8_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":726
+ * 
+ * ctypedef npy_int8       int8_t
+ * ctypedef npy_int16      int16_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_int32      int32_t
+ * ctypedef npy_int64      int64_t
+ */
+typedef npy_int16 __pyx_t_5numpy_int16_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":727
+ * ctypedef npy_int8       int8_t
+ * ctypedef npy_int16      int16_t
+ * ctypedef npy_int32      int32_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_int64      int64_t
+ * #ctypedef npy_int96      int96_t
+ */
+typedef npy_int32 __pyx_t_5numpy_int32_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":728
+ * ctypedef npy_int16      int16_t
+ * ctypedef npy_int32      int32_t
+ * ctypedef npy_int64      int64_t             # <<<<<<<<<<<<<<
+ * #ctypedef npy_int96      int96_t
+ * #ctypedef npy_int128     int128_t
+ */
+typedef npy_int64 __pyx_t_5numpy_int64_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":732
+ * #ctypedef npy_int128     int128_t
+ * 
+ * ctypedef npy_uint8      uint8_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_uint16     uint16_t
+ * ctypedef npy_uint32     uint32_t
+ */
+typedef npy_uint8 __pyx_t_5numpy_uint8_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":733
+ * 
+ * ctypedef npy_uint8      uint8_t
+ * ctypedef npy_uint16     uint16_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_uint32     uint32_t
+ * ctypedef npy_uint64     uint64_t
+ */
+typedef npy_uint16 __pyx_t_5numpy_uint16_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":734
+ * ctypedef npy_uint8      uint8_t
+ * ctypedef npy_uint16     uint16_t
+ * ctypedef npy_uint32     uint32_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_uint64     uint64_t
+ * #ctypedef npy_uint96     uint96_t
+ */
+typedef npy_uint32 __pyx_t_5numpy_uint32_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":735
+ * ctypedef npy_uint16     uint16_t
+ * ctypedef npy_uint32     uint32_t
+ * ctypedef npy_uint64     uint64_t             # <<<<<<<<<<<<<<
+ * #ctypedef npy_uint96     uint96_t
+ * #ctypedef npy_uint128    uint128_t
+ */
+typedef npy_uint64 __pyx_t_5numpy_uint64_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":739
+ * #ctypedef npy_uint128    uint128_t
+ * 
+ * ctypedef npy_float32    float32_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_float64    float64_t
+ * #ctypedef npy_float80    float80_t
+ */
+typedef npy_float32 __pyx_t_5numpy_float32_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":740
+ * 
+ * ctypedef npy_float32    float32_t
+ * ctypedef npy_float64    float64_t             # <<<<<<<<<<<<<<
+ * #ctypedef npy_float80    float80_t
+ * #ctypedef npy_float128   float128_t
+ */
+typedef npy_float64 __pyx_t_5numpy_float64_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":749
+ * # The int types are mapped a bit surprising --
+ * # numpy.int corresponds to 'l' and numpy.long to 'q'
+ * ctypedef npy_long       int_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_longlong   long_t
+ * ctypedef npy_longlong   longlong_t
+ */
+typedef npy_long __pyx_t_5numpy_int_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":750
+ * # numpy.int corresponds to 'l' and numpy.long to 'q'
+ * ctypedef npy_long       int_t
+ * ctypedef npy_longlong   long_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_longlong   longlong_t
+ * 
+ */
+typedef npy_longlong __pyx_t_5numpy_long_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":751
+ * ctypedef npy_long       int_t
+ * ctypedef npy_longlong   long_t
+ * ctypedef npy_longlong   longlong_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_ulong      uint_t
+ */
+typedef npy_longlong __pyx_t_5numpy_longlong_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":753
+ * ctypedef npy_longlong   longlong_t
+ * 
+ * ctypedef npy_ulong      uint_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_ulonglong  ulong_t
+ * ctypedef npy_ulonglong  ulonglong_t
+ */
+typedef npy_ulong __pyx_t_5numpy_uint_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":754
+ * 
+ * ctypedef npy_ulong      uint_t
+ * ctypedef npy_ulonglong  ulong_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_ulonglong  ulonglong_t
+ * 
+ */
+typedef npy_ulonglong __pyx_t_5numpy_ulong_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":755
+ * ctypedef npy_ulong      uint_t
+ * ctypedef npy_ulonglong  ulong_t
+ * ctypedef npy_ulonglong  ulonglong_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_intp       intp_t
+ */
+typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":757
+ * ctypedef npy_ulonglong  ulonglong_t
+ * 
+ * ctypedef npy_intp       intp_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_uintp      uintp_t
+ * 
+ */
+typedef npy_intp __pyx_t_5numpy_intp_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":758
+ * 
+ * ctypedef npy_intp       intp_t
+ * ctypedef npy_uintp      uintp_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_double     float_t
+ */
+typedef npy_uintp __pyx_t_5numpy_uintp_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":760
+ * ctypedef npy_uintp      uintp_t
+ * 
+ * ctypedef npy_double     float_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_double     double_t
+ * ctypedef npy_longdouble longdouble_t
+ */
+typedef npy_double __pyx_t_5numpy_float_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":761
+ * 
+ * ctypedef npy_double     float_t
+ * ctypedef npy_double     double_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_longdouble longdouble_t
+ * 
+ */
+typedef npy_double __pyx_t_5numpy_double_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":762
+ * ctypedef npy_double     float_t
+ * ctypedef npy_double     double_t
+ * ctypedef npy_longdouble longdouble_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_cfloat      cfloat_t
+ */
+typedef npy_longdouble __pyx_t_5numpy_longdouble_t;
+
+/* "bbox.pyx":13
+ * 
+ * DTYPE = np.float
+ * ctypedef np.float_t DTYPE_t             # <<<<<<<<<<<<<<
+ * 
+ * def bbox_overlaps_float(
+ */
+typedef __pyx_t_5numpy_float_t __pyx_t_11cython_bbox_DTYPE_t;
+/* Declarations.proto */
+#if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    typedef ::std::complex< float > __pyx_t_float_complex;
+  #else
+    typedef float _Complex __pyx_t_float_complex;
+  #endif
+#else
+    typedef struct { float real, imag; } __pyx_t_float_complex;
+#endif
+static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float);
+
+/* Declarations.proto */
+#if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    typedef ::std::complex< double > __pyx_t_double_complex;
+  #else
+    typedef double _Complex __pyx_t_double_complex;
+  #endif
+#else
+    typedef struct { double real, imag; } __pyx_t_double_complex;
+#endif
+static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double);
+
+
+/*--- Type declarations ---*/
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":764
+ * ctypedef npy_longdouble longdouble_t
+ * 
+ * ctypedef npy_cfloat      cfloat_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_cdouble     cdouble_t
+ * ctypedef npy_clongdouble clongdouble_t
+ */
+typedef npy_cfloat __pyx_t_5numpy_cfloat_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":765
+ * 
+ * ctypedef npy_cfloat      cfloat_t
+ * ctypedef npy_cdouble     cdouble_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_clongdouble clongdouble_t
+ * 
+ */
+typedef npy_cdouble __pyx_t_5numpy_cdouble_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":766
+ * ctypedef npy_cfloat      cfloat_t
+ * ctypedef npy_cdouble     cdouble_t
+ * ctypedef npy_clongdouble clongdouble_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_cdouble     complex_t
+ */
+typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":768
+ * ctypedef npy_clongdouble clongdouble_t
+ * 
+ * ctypedef npy_cdouble     complex_t             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew1(a):
+ */
+typedef npy_cdouble __pyx_t_5numpy_complex_t;
+
+/* --- Runtime support code (head) --- */
+/* Refnanny.proto */
+#ifndef CYTHON_REFNANNY
+  #define CYTHON_REFNANNY 0
+#endif
+#if CYTHON_REFNANNY
+  typedef struct {
+    void (*INCREF)(void*, PyObject*, int);
+    void (*DECREF)(void*, PyObject*, int);
+    void (*GOTREF)(void*, PyObject*, int);
+    void (*GIVEREF)(void*, PyObject*, int);
+    void* (*SetupContext)(const char*, int, const char*);
+    void (*FinishContext)(void**);
+  } __Pyx_RefNannyAPIStruct;
+  static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
+  static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);
+  #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;
+#ifdef WITH_THREAD
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
+          if (acquire_gil) {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              PyGILState_Release(__pyx_gilstate_save);\
+          } else {\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+          }
+#else
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
+          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+#endif
+  #define __Pyx_RefNannyFinishContext()\
+          __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
+  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
+  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
+  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
+  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
+#else
+  #define __Pyx_RefNannyDeclarations
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContext()
+  #define __Pyx_INCREF(r) Py_INCREF(r)
+  #define __Pyx_DECREF(r) Py_DECREF(r)
+  #define __Pyx_GOTREF(r)
+  #define __Pyx_GIVEREF(r)
+  #define __Pyx_XINCREF(r) Py_XINCREF(r)
+  #define __Pyx_XDECREF(r) Py_XDECREF(r)
+  #define __Pyx_XGOTREF(r)
+  #define __Pyx_XGIVEREF(r)
+#endif
+#define __Pyx_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; __Pyx_XDECREF(tmp);\
+    } while (0)
+#define __Pyx_DECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; __Pyx_DECREF(tmp);\
+    } while (0)
+#define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
+#define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
+
+/* PyObjectGetAttrStr.proto */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro))
+        return tp->tp_getattro(obj, attr_name);
+#if PY_MAJOR_VERSION < 3
+    if (likely(tp->tp_getattr))
+        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
+#endif
+    return PyObject_GetAttr(obj, attr_name);
+}
+#else
+#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
+#endif
+
+/* GetBuiltinName.proto */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name);
+
+/* RaiseArgTupleInvalid.proto */
+static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
+    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
+
+/* RaiseDoubleKeywords.proto */
+static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
+
+/* ParseKeywords.proto */
+static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
+    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
+    const char* function_name);
+
+/* ArgTypeTest.proto */
+static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,
+    const char *name, int exact);
+
+/* BufferFormatCheck.proto */
+static CYTHON_INLINE int  __Pyx_GetBufferAndValidate(Py_buffer* buf, PyObject* obj,
+    __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack);
+static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info);
+static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts);
+static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,
+                              __Pyx_BufFmt_StackElem* stack,
+                              __Pyx_TypeInfo* type); // PROTO
+
+/* GetModuleGlobalName.proto */
+static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name);
+
+/* PyObjectCall.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
+#else
+#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
+#endif
+
+/* ExtTypeTest.proto */
+static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type);
+
+/* BufferIndexError.proto */
+static void __Pyx_RaiseBufferIndexError(int axis);
+
+#define __Pyx_BufPtrStrided2d(type, buf, i0, s0, i1, s1) (type)((char*)buf + i0 * s0 + i1 * s1)
+/* PyThreadStateGet.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
+#define __Pyx_PyThreadState_assign  __pyx_tstate = PyThreadState_GET();
+#else
+#define __Pyx_PyThreadState_declare
+#define __Pyx_PyThreadState_assign
+#endif
+
+/* PyErrFetchRestore.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#else
+#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
+#endif
+
+#define __Pyx_BufPtrStrided1d(type, buf, i0, s0) (type)((char*)buf + i0 * s0)
+/* RaiseException.proto */
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
+
+/* DictGetItem.proto */
+#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
+static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
+    PyObject *value;
+    value = PyDict_GetItemWithError(d, key);
+    if (unlikely(!value)) {
+        if (!PyErr_Occurred()) {
+            PyObject* args = PyTuple_Pack(1, key);
+            if (likely(args))
+                PyErr_SetObject(PyExc_KeyError, args);
+            Py_XDECREF(args);
+        }
+        return NULL;
+    }
+    Py_INCREF(value);
+    return value;
+}
+#else
+    #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key)
+#endif
+
+/* RaiseTooManyValuesToUnpack.proto */
+static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);
+
+/* RaiseNeedMoreValuesToUnpack.proto */
+static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);
+
+/* RaiseNoneIterError.proto */
+static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);
+
+/* SaveResetException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_ExceptionSave(type, value, tb)  __Pyx__ExceptionSave(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#define __Pyx_ExceptionReset(type, value, tb)  __Pyx__ExceptionReset(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+#else
+#define __Pyx_ExceptionSave(type, value, tb)   PyErr_GetExcInfo(type, value, tb)
+#define __Pyx_ExceptionReset(type, value, tb)  PyErr_SetExcInfo(type, value, tb)
+#endif
+
+/* PyErrExceptionMatches.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
+#else
+#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
+#endif
+
+/* GetException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_GetException(type, value, tb)  __Pyx__GetException(__pyx_tstate, type, value, tb)
+static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#else
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb);
+#endif
+
+/* Import.proto */
+static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);
+
+/* CodeObjectCache.proto */
+typedef struct {
+    PyCodeObject* code_object;
+    int code_line;
+} __Pyx_CodeObjectCacheEntry;
+struct __Pyx_CodeObjectCache {
+    int count;
+    int max_count;
+    __Pyx_CodeObjectCacheEntry* entries;
+};
+static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
+static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
+static PyCodeObject *__pyx_find_code_object(int code_line);
+static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
+
+/* AddTraceback.proto */
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename);
+
+/* BufferStructDeclare.proto */
+typedef struct {
+  Py_ssize_t shape, strides, suboffsets;
+} __Pyx_Buf_DimInfo;
+typedef struct {
+  size_t refcount;
+  Py_buffer pybuffer;
+} __Pyx_Buffer;
+typedef struct {
+  __Pyx_Buffer *rcbuffer;
+  char *data;
+  __Pyx_Buf_DimInfo diminfo[8];
+} __Pyx_LocalBuf_ND;
+
+#if PY_MAJOR_VERSION < 3
+    static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags);
+    static void __Pyx_ReleaseBuffer(Py_buffer *view);
+#else
+    #define __Pyx_GetBuffer PyObject_GetBuffer
+    #define __Pyx_ReleaseBuffer PyBuffer_Release
+#endif
+
+
+/* None.proto */
+static Py_ssize_t __Pyx_zeros[] = {0, 0, 0, 0, 0, 0, 0, 0};
+static Py_ssize_t __Pyx_minusones[] = {-1, -1, -1, -1, -1, -1, -1, -1};
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value);
+
+/* RealImag.proto */
+#if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    #define __Pyx_CREAL(z) ((z).real())
+    #define __Pyx_CIMAG(z) ((z).imag())
+  #else
+    #define __Pyx_CREAL(z) (__real__(z))
+    #define __Pyx_CIMAG(z) (__imag__(z))
+  #endif
+#else
+    #define __Pyx_CREAL(z) ((z).real)
+    #define __Pyx_CIMAG(z) ((z).imag)
+#endif
+#if defined(__cplusplus) && CYTHON_CCOMPLEX\
+        && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103)
+    #define __Pyx_SET_CREAL(z,x) ((z).real(x))
+    #define __Pyx_SET_CIMAG(z,y) ((z).imag(y))
+#else
+    #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x)
+    #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y)
+#endif
+
+/* Arithmetic.proto */
+#if CYTHON_CCOMPLEX
+    #define __Pyx_c_eq_float(a, b)   ((a)==(b))
+    #define __Pyx_c_sum_float(a, b)  ((a)+(b))
+    #define __Pyx_c_diff_float(a, b) ((a)-(b))
+    #define __Pyx_c_prod_float(a, b) ((a)*(b))
+    #define __Pyx_c_quot_float(a, b) ((a)/(b))
+    #define __Pyx_c_neg_float(a)     (-(a))
+  #ifdef __cplusplus
+    #define __Pyx_c_is_zero_float(z) ((z)==(float)0)
+    #define __Pyx_c_conj_float(z)    (::std::conj(z))
+    #if 1
+        #define __Pyx_c_abs_float(z)     (::std::abs(z))
+        #define __Pyx_c_pow_float(a, b)  (::std::pow(a, b))
+    #endif
+  #else
+    #define __Pyx_c_is_zero_float(z) ((z)==0)
+    #define __Pyx_c_conj_float(z)    (conjf(z))
+    #if 1
+        #define __Pyx_c_abs_float(z)     (cabsf(z))
+        #define __Pyx_c_pow_float(a, b)  (cpowf(a, b))
+    #endif
+ #endif
+#else
+    static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex);
+    static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex);
+    #if 1
+        static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex);
+        static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    #endif
+#endif
+
+/* Arithmetic.proto */
+#if CYTHON_CCOMPLEX
+    #define __Pyx_c_eq_double(a, b)   ((a)==(b))
+    #define __Pyx_c_sum_double(a, b)  ((a)+(b))
+    #define __Pyx_c_diff_double(a, b) ((a)-(b))
+    #define __Pyx_c_prod_double(a, b) ((a)*(b))
+    #define __Pyx_c_quot_double(a, b) ((a)/(b))
+    #define __Pyx_c_neg_double(a)     (-(a))
+  #ifdef __cplusplus
+    #define __Pyx_c_is_zero_double(z) ((z)==(double)0)
+    #define __Pyx_c_conj_double(z)    (::std::conj(z))
+    #if 1
+        #define __Pyx_c_abs_double(z)     (::std::abs(z))
+        #define __Pyx_c_pow_double(a, b)  (::std::pow(a, b))
+    #endif
+  #else
+    #define __Pyx_c_is_zero_double(z) ((z)==0)
+    #define __Pyx_c_conj_double(z)    (conj(z))
+    #if 1
+        #define __Pyx_c_abs_double(z)     (cabs(z))
+        #define __Pyx_c_pow_double(a, b)  (cpow(a, b))
+    #endif
+ #endif
+#else
+    static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex);
+    static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex);
+    #if 1
+        static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex);
+        static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    #endif
+#endif
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
+
+/* CheckBinaryVersion.proto */
+static int __Pyx_check_binary_version(void);
+
+/* PyIdentifierFromString.proto */
+#if !defined(__Pyx_PyIdentifier_FromString)
+#if PY_MAJOR_VERSION < 3
+  #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s)
+#else
+  #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s)
+#endif
+#endif
+
+/* ModuleImport.proto */
+static PyObject *__Pyx_ImportModule(const char *name);
+
+/* TypeImport.proto */
+static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict);
+
+/* InitStrings.proto */
+static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
+
+
+/* Module declarations from 'cython' */
+
+/* Module declarations from 'cpython.buffer' */
+
+/* Module declarations from 'libc.string' */
+
+/* Module declarations from 'libc.stdio' */
+
+/* Module declarations from '__builtin__' */
+
+/* Module declarations from 'cpython.type' */
+static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0;
+
+/* Module declarations from 'cpython' */
+
+/* Module declarations from 'cpython.object' */
+
+/* Module declarations from 'cpython.ref' */
+
+/* Module declarations from 'libc.stdlib' */
+
+/* Module declarations from 'numpy' */
+
+/* Module declarations from 'numpy' */
+static PyTypeObject *__pyx_ptype_5numpy_dtype = 0;
+static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0;
+static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0;
+static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0;
+static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0;
+static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/
+
+/* Module declarations from 'cython_bbox' */
+static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_11cython_bbox_DTYPE_t = { "DTYPE_t", NULL, sizeof(__pyx_t_11cython_bbox_DTYPE_t), { 0 }, 0, 'R', 0, 0 };
+static __Pyx_TypeInfo __Pyx_TypeInfo_long = { "long", NULL, sizeof(long), { 0 }, 0, IS_UNSIGNED(long) ? 'U' : 'I', IS_UNSIGNED(long), 0 };
+#define __Pyx_MODULE_NAME "cython_bbox"
+int __pyx_module_is_main_cython_bbox = 0;
+
+/* Implementation of 'cython_bbox' */
+static PyObject *__pyx_builtin_range;
+static PyObject *__pyx_builtin_ValueError;
+static PyObject *__pyx_builtin_RuntimeError;
+static PyObject *__pyx_builtin_ImportError;
+static const char __pyx_k_K[] = "K";
+static const char __pyx_k_N[] = "N";
+static const char __pyx_k_k[] = "k";
+static const char __pyx_k_n[] = "n";
+static const char __pyx_k_ih[] = "ih";
+static const char __pyx_k_iw[] = "iw";
+static const char __pyx_k_np[] = "np";
+static const char __pyx_k_ua[] = "ua";
+static const char __pyx_k_int[] = "int";
+static const char __pyx_k_main[] = "__main__";
+static const char __pyx_k_test[] = "__test__";
+static const char __pyx_k_DTYPE[] = "DTYPE";
+static const char __pyx_k_boxes[] = "boxes";
+static const char __pyx_k_dtype[] = "dtype";
+static const char __pyx_k_float[] = "float";
+static const char __pyx_k_numpy[] = "numpy";
+static const char __pyx_k_range[] = "range";
+static const char __pyx_k_zeros[] = "zeros";
+static const char __pyx_k_import[] = "__import__";
+static const char __pyx_k_overlap[] = "overlap";
+static const char __pyx_k_box_area[] = "box_area";
+static const char __pyx_k_overlaps[] = "overlaps";
+static const char __pyx_k_FG_THRESH[] = "FG_THRESH";
+static const char __pyx_k_ValueError[] = "ValueError";
+static const char __pyx_k_ImportError[] = "ImportError";
+static const char __pyx_k_cython_bbox[] = "cython_bbox";
+static const char __pyx_k_query_boxes[] = "query_boxes";
+static const char __pyx_k_RuntimeError[] = "RuntimeError";
+static const char __pyx_k_max_overlaps[] = "max_overlaps";
+static const char __pyx_k_bbox_overlaps[] = "bbox_overlaps";
+static const char __pyx_k_gt_assignment[] = "gt_assignment";
+static const char __pyx_k_bbox_overlaps_self[] = "bbox_overlaps_self";
+static const char __pyx_k_bbox_overlaps_float[] = "bbox_overlaps_float";
+static const char __pyx_k_bbox_overlaps_ignore[] = "bbox_overlaps_ignore";
+static const char __pyx_k_get_assignment_overlaps[] = "get_assignment_overlaps";
+static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous";
+static const char __pyx_k_home_yjr_PycharmProjects_Faster[] = "/home/yjr/PycharmProjects/Faster-RCNN_Tensorflow/libs/box_utils/cython_utils/bbox.pyx";
+static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import";
+static const char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)";
+static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd";
+static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported";
+static const char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous";
+static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import";
+static const char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short.";
+static PyObject *__pyx_n_s_DTYPE;
+static PyObject *__pyx_n_s_FG_THRESH;
+static PyObject *__pyx_kp_u_Format_string_allocated_too_shor;
+static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2;
+static PyObject *__pyx_n_s_ImportError;
+static PyObject *__pyx_n_s_K;
+static PyObject *__pyx_n_s_N;
+static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor;
+static PyObject *__pyx_n_s_RuntimeError;
+static PyObject *__pyx_n_s_ValueError;
+static PyObject *__pyx_n_s_bbox_overlaps;
+static PyObject *__pyx_n_s_bbox_overlaps_float;
+static PyObject *__pyx_n_s_bbox_overlaps_ignore;
+static PyObject *__pyx_n_s_bbox_overlaps_self;
+static PyObject *__pyx_n_s_box_area;
+static PyObject *__pyx_n_s_boxes;
+static PyObject *__pyx_n_s_cython_bbox;
+static PyObject *__pyx_n_s_dtype;
+static PyObject *__pyx_n_s_float;
+static PyObject *__pyx_n_s_get_assignment_overlaps;
+static PyObject *__pyx_n_s_gt_assignment;
+static PyObject *__pyx_kp_s_home_yjr_PycharmProjects_Faster;
+static PyObject *__pyx_n_s_ih;
+static PyObject *__pyx_n_s_import;
+static PyObject *__pyx_n_s_int;
+static PyObject *__pyx_n_s_iw;
+static PyObject *__pyx_n_s_k;
+static PyObject *__pyx_n_s_main;
+static PyObject *__pyx_n_s_max_overlaps;
+static PyObject *__pyx_n_s_n;
+static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous;
+static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou;
+static PyObject *__pyx_n_s_np;
+static PyObject *__pyx_n_s_numpy;
+static PyObject *__pyx_kp_s_numpy_core_multiarray_failed_to;
+static PyObject *__pyx_kp_s_numpy_core_umath_failed_to_impor;
+static PyObject *__pyx_n_s_overlap;
+static PyObject *__pyx_n_s_overlaps;
+static PyObject *__pyx_n_s_query_boxes;
+static PyObject *__pyx_n_s_range;
+static PyObject *__pyx_n_s_test;
+static PyObject *__pyx_n_s_ua;
+static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd;
+static PyObject *__pyx_n_s_zeros;
+static PyObject *__pyx_pf_11cython_bbox_bbox_overlaps_float(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_boxes, PyArrayObject *__pyx_v_query_boxes); /* proto */
+static PyObject *__pyx_pf_11cython_bbox_2bbox_overlaps(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_boxes, PyArrayObject *__pyx_v_query_boxes); /* proto */
+static PyObject *__pyx_pf_11cython_bbox_4bbox_overlaps_self(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_boxes, PyArrayObject *__pyx_v_query_boxes); /* proto */
+static PyObject *__pyx_pf_11cython_bbox_6bbox_overlaps_ignore(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_boxes, PyArrayObject *__pyx_v_query_boxes); /* proto */
+static PyObject *__pyx_pf_11cython_bbox_8get_assignment_overlaps(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_boxes, PyArrayObject *__pyx_v_query_boxes, __pyx_t_11cython_bbox_DTYPE_t __pyx_v_FG_THRESH); /* proto */
+static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */
+static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */
+static PyObject *__pyx_tuple_;
+static PyObject *__pyx_tuple__2;
+static PyObject *__pyx_tuple__3;
+static PyObject *__pyx_tuple__4;
+static PyObject *__pyx_tuple__5;
+static PyObject *__pyx_tuple__6;
+static PyObject *__pyx_tuple__7;
+static PyObject *__pyx_tuple__8;
+static PyObject *__pyx_tuple__9;
+static PyObject *__pyx_tuple__10;
+static PyObject *__pyx_tuple__12;
+static PyObject *__pyx_tuple__14;
+static PyObject *__pyx_tuple__16;
+static PyObject *__pyx_tuple__18;
+static PyObject *__pyx_codeobj__11;
+static PyObject *__pyx_codeobj__13;
+static PyObject *__pyx_codeobj__15;
+static PyObject *__pyx_codeobj__17;
+static PyObject *__pyx_codeobj__19;
+
+/* "bbox.pyx":15
+ * ctypedef np.float_t DTYPE_t
+ * 
+ * def bbox_overlaps_float(             # <<<<<<<<<<<<<<
+ *         np.ndarray[DTYPE_t, ndim=2] boxes,
+ *         np.ndarray[DTYPE_t, ndim=2] query_boxes):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11cython_bbox_1bbox_overlaps_float(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_11cython_bbox_bbox_overlaps_float[] = "\n    Parameters\n    ----------\n    boxes: (N, 4) ndarray of float\n    query_boxes: (K, 4) ndarray of float\n    Returns\n    -------\n    overlaps: (N, K) ndarray of overlap between boxes and query_boxes\n    ";
+static PyMethodDef __pyx_mdef_11cython_bbox_1bbox_overlaps_float = {"bbox_overlaps_float", (PyCFunction)__pyx_pw_11cython_bbox_1bbox_overlaps_float, METH_VARARGS|METH_KEYWORDS, __pyx_doc_11cython_bbox_bbox_overlaps_float};
+static PyObject *__pyx_pw_11cython_bbox_1bbox_overlaps_float(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyArrayObject *__pyx_v_boxes = 0;
+  PyArrayObject *__pyx_v_query_boxes = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("bbox_overlaps_float (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_boxes,&__pyx_n_s_query_boxes,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_boxes)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_query_boxes)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("bbox_overlaps_float", 1, 2, 2, 1); __PYX_ERR(0, 15, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "bbox_overlaps_float") < 0)) __PYX_ERR(0, 15, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_boxes = ((PyArrayObject *)values[0]);
+    __pyx_v_query_boxes = ((PyArrayObject *)values[1]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("bbox_overlaps_float", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 15, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("cython_bbox.bbox_overlaps_float", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_boxes), __pyx_ptype_5numpy_ndarray, 1, "boxes", 0))) __PYX_ERR(0, 16, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_query_boxes), __pyx_ptype_5numpy_ndarray, 1, "query_boxes", 0))) __PYX_ERR(0, 17, __pyx_L1_error)
+  __pyx_r = __pyx_pf_11cython_bbox_bbox_overlaps_float(__pyx_self, __pyx_v_boxes, __pyx_v_query_boxes);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_11cython_bbox_bbox_overlaps_float(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_boxes, PyArrayObject *__pyx_v_query_boxes) {
+  unsigned int __pyx_v_N;
+  unsigned int __pyx_v_K;
+  PyArrayObject *__pyx_v_overlaps = 0;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_v_iw;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_v_ih;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_v_box_area;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_v_ua;
+  unsigned int __pyx_v_k;
+  unsigned int __pyx_v_n;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_boxes;
+  __Pyx_Buffer __pyx_pybuffer_boxes;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_overlaps;
+  __Pyx_Buffer __pyx_pybuffer_overlaps;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_query_boxes;
+  __Pyx_Buffer __pyx_pybuffer_query_boxes;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyArrayObject *__pyx_t_5 = NULL;
+  unsigned int __pyx_t_6;
+  unsigned int __pyx_t_7;
+  size_t __pyx_t_8;
+  Py_ssize_t __pyx_t_9;
+  int __pyx_t_10;
+  size_t __pyx_t_11;
+  Py_ssize_t __pyx_t_12;
+  size_t __pyx_t_13;
+  Py_ssize_t __pyx_t_14;
+  size_t __pyx_t_15;
+  Py_ssize_t __pyx_t_16;
+  unsigned int __pyx_t_17;
+  unsigned int __pyx_t_18;
+  size_t __pyx_t_19;
+  Py_ssize_t __pyx_t_20;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_t_21;
+  size_t __pyx_t_22;
+  Py_ssize_t __pyx_t_23;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_t_24;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_t_25;
+  size_t __pyx_t_26;
+  Py_ssize_t __pyx_t_27;
+  size_t __pyx_t_28;
+  Py_ssize_t __pyx_t_29;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_t_30;
+  int __pyx_t_31;
+  size_t __pyx_t_32;
+  Py_ssize_t __pyx_t_33;
+  size_t __pyx_t_34;
+  Py_ssize_t __pyx_t_35;
+  size_t __pyx_t_36;
+  Py_ssize_t __pyx_t_37;
+  size_t __pyx_t_38;
+  Py_ssize_t __pyx_t_39;
+  size_t __pyx_t_40;
+  Py_ssize_t __pyx_t_41;
+  size_t __pyx_t_42;
+  Py_ssize_t __pyx_t_43;
+  size_t __pyx_t_44;
+  Py_ssize_t __pyx_t_45;
+  size_t __pyx_t_46;
+  Py_ssize_t __pyx_t_47;
+  size_t __pyx_t_48;
+  size_t __pyx_t_49;
+  __Pyx_RefNannySetupContext("bbox_overlaps_float", 0);
+  __pyx_pybuffer_overlaps.pybuffer.buf = NULL;
+  __pyx_pybuffer_overlaps.refcount = 0;
+  __pyx_pybuffernd_overlaps.data = NULL;
+  __pyx_pybuffernd_overlaps.rcbuffer = &__pyx_pybuffer_overlaps;
+  __pyx_pybuffer_boxes.pybuffer.buf = NULL;
+  __pyx_pybuffer_boxes.refcount = 0;
+  __pyx_pybuffernd_boxes.data = NULL;
+  __pyx_pybuffernd_boxes.rcbuffer = &__pyx_pybuffer_boxes;
+  __pyx_pybuffer_query_boxes.pybuffer.buf = NULL;
+  __pyx_pybuffer_query_boxes.refcount = 0;
+  __pyx_pybuffernd_query_boxes.data = NULL;
+  __pyx_pybuffernd_query_boxes.rcbuffer = &__pyx_pybuffer_query_boxes;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer, (PyObject*)__pyx_v_boxes, &__Pyx_TypeInfo_nn___pyx_t_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 15, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_boxes.diminfo[0].strides = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_boxes.diminfo[0].shape = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_boxes.diminfo[1].strides = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_boxes.diminfo[1].shape = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.shape[1];
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer, (PyObject*)__pyx_v_query_boxes, &__Pyx_TypeInfo_nn___pyx_t_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 15, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_query_boxes.diminfo[0].strides = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_query_boxes.diminfo[0].shape = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_query_boxes.diminfo[1].strides = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_query_boxes.diminfo[1].shape = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.shape[1];
+
+  /* "bbox.pyx":27
+ *     overlaps: (N, K) ndarray of overlap between boxes and query_boxes
+ *     """
+ *     cdef unsigned int N = boxes.shape[0]             # <<<<<<<<<<<<<<
+ *     cdef unsigned int K = query_boxes.shape[0]
+ *     cdef np.ndarray[DTYPE_t, ndim=2] overlaps = np.zeros((N, K), dtype=DTYPE)
+ */
+  __pyx_v_N = (__pyx_v_boxes->dimensions[0]);
+
+  /* "bbox.pyx":28
+ *     """
+ *     cdef unsigned int N = boxes.shape[0]
+ *     cdef unsigned int K = query_boxes.shape[0]             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[DTYPE_t, ndim=2] overlaps = np.zeros((N, K), dtype=DTYPE)
+ *     cdef DTYPE_t iw, ih, box_area
+ */
+  __pyx_v_K = (__pyx_v_query_boxes->dimensions[0]);
+
+  /* "bbox.pyx":29
+ *     cdef unsigned int N = boxes.shape[0]
+ *     cdef unsigned int K = query_boxes.shape[0]
+ *     cdef np.ndarray[DTYPE_t, ndim=2] overlaps = np.zeros((N, K), dtype=DTYPE)             # <<<<<<<<<<<<<<
+ *     cdef DTYPE_t iw, ih, box_area
+ *     cdef DTYPE_t ua
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_N); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_K); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
+  __pyx_t_1 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
+  __pyx_t_4 = 0;
+  __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 29, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 29, __pyx_L1_error)
+  __pyx_t_5 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_overlaps.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) {
+      __pyx_v_overlaps = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 29, __pyx_L1_error)
+    } else {__pyx_pybuffernd_overlaps.diminfo[0].strides = __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_overlaps.diminfo[0].shape = __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_overlaps.diminfo[1].strides = __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_overlaps.diminfo[1].shape = __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.shape[1];
+    }
+  }
+  __pyx_t_5 = 0;
+  __pyx_v_overlaps = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "bbox.pyx":33
+ *     cdef DTYPE_t ua
+ *     cdef unsigned int k, n
+ *     for k in range(K):             # <<<<<<<<<<<<<<
+ *         box_area = (
+ *             (query_boxes[k, 2] - query_boxes[k, 0]) *
+ */
+  __pyx_t_6 = __pyx_v_K;
+  for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) {
+    __pyx_v_k = __pyx_t_7;
+
+    /* "bbox.pyx":35
+ *     for k in range(K):
+ *         box_area = (
+ *             (query_boxes[k, 2] - query_boxes[k, 0]) *             # <<<<<<<<<<<<<<
+ *             (query_boxes[k, 3] - query_boxes[k, 1])
+ *         )
+ */
+    __pyx_t_8 = __pyx_v_k;
+    __pyx_t_9 = 2;
+    __pyx_t_10 = -1;
+    if (unlikely(__pyx_t_8 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+    if (__pyx_t_9 < 0) {
+      __pyx_t_9 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+      if (unlikely(__pyx_t_9 < 0)) __pyx_t_10 = 1;
+    } else if (unlikely(__pyx_t_9 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+    if (unlikely(__pyx_t_10 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_10);
+      __PYX_ERR(0, 35, __pyx_L1_error)
+    }
+    __pyx_t_11 = __pyx_v_k;
+    __pyx_t_12 = 0;
+    __pyx_t_10 = -1;
+    if (unlikely(__pyx_t_11 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+    if (__pyx_t_12 < 0) {
+      __pyx_t_12 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+      if (unlikely(__pyx_t_12 < 0)) __pyx_t_10 = 1;
+    } else if (unlikely(__pyx_t_12 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+    if (unlikely(__pyx_t_10 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_10);
+      __PYX_ERR(0, 35, __pyx_L1_error)
+    }
+
+    /* "bbox.pyx":36
+ *         box_area = (
+ *             (query_boxes[k, 2] - query_boxes[k, 0]) *
+ *             (query_boxes[k, 3] - query_boxes[k, 1])             # <<<<<<<<<<<<<<
+ *         )
+ *         for n in range(N):
+ */
+    __pyx_t_13 = __pyx_v_k;
+    __pyx_t_14 = 3;
+    __pyx_t_10 = -1;
+    if (unlikely(__pyx_t_13 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+    if (__pyx_t_14 < 0) {
+      __pyx_t_14 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+      if (unlikely(__pyx_t_14 < 0)) __pyx_t_10 = 1;
+    } else if (unlikely(__pyx_t_14 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+    if (unlikely(__pyx_t_10 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_10);
+      __PYX_ERR(0, 36, __pyx_L1_error)
+    }
+    __pyx_t_15 = __pyx_v_k;
+    __pyx_t_16 = 1;
+    __pyx_t_10 = -1;
+    if (unlikely(__pyx_t_15 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+    if (__pyx_t_16 < 0) {
+      __pyx_t_16 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+      if (unlikely(__pyx_t_16 < 0)) __pyx_t_10 = 1;
+    } else if (unlikely(__pyx_t_16 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+    if (unlikely(__pyx_t_10 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_10);
+      __PYX_ERR(0, 36, __pyx_L1_error)
+    }
+
+    /* "bbox.pyx":35
+ *     for k in range(K):
+ *         box_area = (
+ *             (query_boxes[k, 2] - query_boxes[k, 0]) *             # <<<<<<<<<<<<<<
+ *             (query_boxes[k, 3] - query_boxes[k, 1])
+ *         )
+ */
+    __pyx_v_box_area = (((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_9, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_11, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_12, __pyx_pybuffernd_query_boxes.diminfo[1].strides))) * ((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_13, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_14, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_16, __pyx_pybuffernd_query_boxes.diminfo[1].strides))));
+
+    /* "bbox.pyx":38
+ *             (query_boxes[k, 3] - query_boxes[k, 1])
+ *         )
+ *         for n in range(N):             # <<<<<<<<<<<<<<
+ *             iw = (
+ *                 min(boxes[n, 2], query_boxes[k, 2]) -
+ */
+    __pyx_t_17 = __pyx_v_N;
+    for (__pyx_t_18 = 0; __pyx_t_18 < __pyx_t_17; __pyx_t_18+=1) {
+      __pyx_v_n = __pyx_t_18;
+
+      /* "bbox.pyx":40
+ *         for n in range(N):
+ *             iw = (
+ *                 min(boxes[n, 2], query_boxes[k, 2]) -             # <<<<<<<<<<<<<<
+ *                 max(boxes[n, 0], query_boxes[k, 0])
+ *             )
+ */
+      __pyx_t_19 = __pyx_v_k;
+      __pyx_t_20 = 2;
+      __pyx_t_10 = -1;
+      if (unlikely(__pyx_t_19 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+      if (__pyx_t_20 < 0) {
+        __pyx_t_20 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+        if (unlikely(__pyx_t_20 < 0)) __pyx_t_10 = 1;
+      } else if (unlikely(__pyx_t_20 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+      if (unlikely(__pyx_t_10 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_10);
+        __PYX_ERR(0, 40, __pyx_L1_error)
+      }
+      __pyx_t_21 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_19, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_20, __pyx_pybuffernd_query_boxes.diminfo[1].strides));
+      __pyx_t_22 = __pyx_v_n;
+      __pyx_t_23 = 2;
+      __pyx_t_10 = -1;
+      if (unlikely(__pyx_t_22 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+      if (__pyx_t_23 < 0) {
+        __pyx_t_23 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+        if (unlikely(__pyx_t_23 < 0)) __pyx_t_10 = 1;
+      } else if (unlikely(__pyx_t_23 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+      if (unlikely(__pyx_t_10 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_10);
+        __PYX_ERR(0, 40, __pyx_L1_error)
+      }
+      __pyx_t_24 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_22, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_23, __pyx_pybuffernd_boxes.diminfo[1].strides));
+      if (((__pyx_t_21 < __pyx_t_24) != 0)) {
+        __pyx_t_25 = __pyx_t_21;
+      } else {
+        __pyx_t_25 = __pyx_t_24;
+      }
+
+      /* "bbox.pyx":41
+ *             iw = (
+ *                 min(boxes[n, 2], query_boxes[k, 2]) -
+ *                 max(boxes[n, 0], query_boxes[k, 0])             # <<<<<<<<<<<<<<
+ *             )
+ *             if iw > 0:
+ */
+      __pyx_t_26 = __pyx_v_k;
+      __pyx_t_27 = 0;
+      __pyx_t_10 = -1;
+      if (unlikely(__pyx_t_26 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+      if (__pyx_t_27 < 0) {
+        __pyx_t_27 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+        if (unlikely(__pyx_t_27 < 0)) __pyx_t_10 = 1;
+      } else if (unlikely(__pyx_t_27 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+      if (unlikely(__pyx_t_10 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_10);
+        __PYX_ERR(0, 41, __pyx_L1_error)
+      }
+      __pyx_t_21 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_26, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_27, __pyx_pybuffernd_query_boxes.diminfo[1].strides));
+      __pyx_t_28 = __pyx_v_n;
+      __pyx_t_29 = 0;
+      __pyx_t_10 = -1;
+      if (unlikely(__pyx_t_28 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+      if (__pyx_t_29 < 0) {
+        __pyx_t_29 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+        if (unlikely(__pyx_t_29 < 0)) __pyx_t_10 = 1;
+      } else if (unlikely(__pyx_t_29 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+      if (unlikely(__pyx_t_10 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_10);
+        __PYX_ERR(0, 41, __pyx_L1_error)
+      }
+      __pyx_t_24 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_28, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_29, __pyx_pybuffernd_boxes.diminfo[1].strides));
+      if (((__pyx_t_21 > __pyx_t_24) != 0)) {
+        __pyx_t_30 = __pyx_t_21;
+      } else {
+        __pyx_t_30 = __pyx_t_24;
+      }
+
+      /* "bbox.pyx":40
+ *         for n in range(N):
+ *             iw = (
+ *                 min(boxes[n, 2], query_boxes[k, 2]) -             # <<<<<<<<<<<<<<
+ *                 max(boxes[n, 0], query_boxes[k, 0])
+ *             )
+ */
+      __pyx_v_iw = (__pyx_t_25 - __pyx_t_30);
+
+      /* "bbox.pyx":43
+ *                 max(boxes[n, 0], query_boxes[k, 0])
+ *             )
+ *             if iw > 0:             # <<<<<<<<<<<<<<
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -
+ */
+      __pyx_t_31 = ((__pyx_v_iw > 0.0) != 0);
+      if (__pyx_t_31) {
+
+        /* "bbox.pyx":45
+ *             if iw > 0:
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -             # <<<<<<<<<<<<<<
+ *                     max(boxes[n, 1], query_boxes[k, 1])
+ *                 )
+ */
+        __pyx_t_32 = __pyx_v_k;
+        __pyx_t_33 = 3;
+        __pyx_t_10 = -1;
+        if (unlikely(__pyx_t_32 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+        if (__pyx_t_33 < 0) {
+          __pyx_t_33 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+          if (unlikely(__pyx_t_33 < 0)) __pyx_t_10 = 1;
+        } else if (unlikely(__pyx_t_33 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+        if (unlikely(__pyx_t_10 != -1)) {
+          __Pyx_RaiseBufferIndexError(__pyx_t_10);
+          __PYX_ERR(0, 45, __pyx_L1_error)
+        }
+        __pyx_t_30 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_32, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_33, __pyx_pybuffernd_query_boxes.diminfo[1].strides));
+        __pyx_t_34 = __pyx_v_n;
+        __pyx_t_35 = 3;
+        __pyx_t_10 = -1;
+        if (unlikely(__pyx_t_34 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+        if (__pyx_t_35 < 0) {
+          __pyx_t_35 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+          if (unlikely(__pyx_t_35 < 0)) __pyx_t_10 = 1;
+        } else if (unlikely(__pyx_t_35 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+        if (unlikely(__pyx_t_10 != -1)) {
+          __Pyx_RaiseBufferIndexError(__pyx_t_10);
+          __PYX_ERR(0, 45, __pyx_L1_error)
+        }
+        __pyx_t_25 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_34, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_35, __pyx_pybuffernd_boxes.diminfo[1].strides));
+        if (((__pyx_t_30 < __pyx_t_25) != 0)) {
+          __pyx_t_21 = __pyx_t_30;
+        } else {
+          __pyx_t_21 = __pyx_t_25;
+        }
+
+        /* "bbox.pyx":46
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -
+ *                     max(boxes[n, 1], query_boxes[k, 1])             # <<<<<<<<<<<<<<
+ *                 )
+ *                 if ih > 0:
+ */
+        __pyx_t_36 = __pyx_v_k;
+        __pyx_t_37 = 1;
+        __pyx_t_10 = -1;
+        if (unlikely(__pyx_t_36 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+        if (__pyx_t_37 < 0) {
+          __pyx_t_37 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+          if (unlikely(__pyx_t_37 < 0)) __pyx_t_10 = 1;
+        } else if (unlikely(__pyx_t_37 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+        if (unlikely(__pyx_t_10 != -1)) {
+          __Pyx_RaiseBufferIndexError(__pyx_t_10);
+          __PYX_ERR(0, 46, __pyx_L1_error)
+        }
+        __pyx_t_30 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_36, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_37, __pyx_pybuffernd_query_boxes.diminfo[1].strides));
+        __pyx_t_38 = __pyx_v_n;
+        __pyx_t_39 = 1;
+        __pyx_t_10 = -1;
+        if (unlikely(__pyx_t_38 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+        if (__pyx_t_39 < 0) {
+          __pyx_t_39 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+          if (unlikely(__pyx_t_39 < 0)) __pyx_t_10 = 1;
+        } else if (unlikely(__pyx_t_39 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+        if (unlikely(__pyx_t_10 != -1)) {
+          __Pyx_RaiseBufferIndexError(__pyx_t_10);
+          __PYX_ERR(0, 46, __pyx_L1_error)
+        }
+        __pyx_t_25 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_38, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_39, __pyx_pybuffernd_boxes.diminfo[1].strides));
+        if (((__pyx_t_30 > __pyx_t_25) != 0)) {
+          __pyx_t_24 = __pyx_t_30;
+        } else {
+          __pyx_t_24 = __pyx_t_25;
+        }
+
+        /* "bbox.pyx":45
+ *             if iw > 0:
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -             # <<<<<<<<<<<<<<
+ *                     max(boxes[n, 1], query_boxes[k, 1])
+ *                 )
+ */
+        __pyx_v_ih = (__pyx_t_21 - __pyx_t_24);
+
+        /* "bbox.pyx":48
+ *                     max(boxes[n, 1], query_boxes[k, 1])
+ *                 )
+ *                 if ih > 0:             # <<<<<<<<<<<<<<
+ *                     ua = float(
+ *                         (boxes[n, 2] - boxes[n, 0]) *
+ */
+        __pyx_t_31 = ((__pyx_v_ih > 0.0) != 0);
+        if (__pyx_t_31) {
+
+          /* "bbox.pyx":50
+ *                 if ih > 0:
+ *                     ua = float(
+ *                         (boxes[n, 2] - boxes[n, 0]) *             # <<<<<<<<<<<<<<
+ *                         (boxes[n, 3] - boxes[n, 1]) +
+ *                         box_area - iw * ih
+ */
+          __pyx_t_40 = __pyx_v_n;
+          __pyx_t_41 = 2;
+          __pyx_t_10 = -1;
+          if (unlikely(__pyx_t_40 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+          if (__pyx_t_41 < 0) {
+            __pyx_t_41 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+            if (unlikely(__pyx_t_41 < 0)) __pyx_t_10 = 1;
+          } else if (unlikely(__pyx_t_41 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+          if (unlikely(__pyx_t_10 != -1)) {
+            __Pyx_RaiseBufferIndexError(__pyx_t_10);
+            __PYX_ERR(0, 50, __pyx_L1_error)
+          }
+          __pyx_t_42 = __pyx_v_n;
+          __pyx_t_43 = 0;
+          __pyx_t_10 = -1;
+          if (unlikely(__pyx_t_42 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+          if (__pyx_t_43 < 0) {
+            __pyx_t_43 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+            if (unlikely(__pyx_t_43 < 0)) __pyx_t_10 = 1;
+          } else if (unlikely(__pyx_t_43 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+          if (unlikely(__pyx_t_10 != -1)) {
+            __Pyx_RaiseBufferIndexError(__pyx_t_10);
+            __PYX_ERR(0, 50, __pyx_L1_error)
+          }
+
+          /* "bbox.pyx":51
+ *                     ua = float(
+ *                         (boxes[n, 2] - boxes[n, 0]) *
+ *                         (boxes[n, 3] - boxes[n, 1]) +             # <<<<<<<<<<<<<<
+ *                         box_area - iw * ih
+ *                     )
+ */
+          __pyx_t_44 = __pyx_v_n;
+          __pyx_t_45 = 3;
+          __pyx_t_10 = -1;
+          if (unlikely(__pyx_t_44 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+          if (__pyx_t_45 < 0) {
+            __pyx_t_45 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+            if (unlikely(__pyx_t_45 < 0)) __pyx_t_10 = 1;
+          } else if (unlikely(__pyx_t_45 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+          if (unlikely(__pyx_t_10 != -1)) {
+            __Pyx_RaiseBufferIndexError(__pyx_t_10);
+            __PYX_ERR(0, 51, __pyx_L1_error)
+          }
+          __pyx_t_46 = __pyx_v_n;
+          __pyx_t_47 = 1;
+          __pyx_t_10 = -1;
+          if (unlikely(__pyx_t_46 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+          if (__pyx_t_47 < 0) {
+            __pyx_t_47 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+            if (unlikely(__pyx_t_47 < 0)) __pyx_t_10 = 1;
+          } else if (unlikely(__pyx_t_47 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+          if (unlikely(__pyx_t_10 != -1)) {
+            __Pyx_RaiseBufferIndexError(__pyx_t_10);
+            __PYX_ERR(0, 51, __pyx_L1_error)
+          }
+
+          /* "bbox.pyx":49
+ *                 )
+ *                 if ih > 0:
+ *                     ua = float(             # <<<<<<<<<<<<<<
+ *                         (boxes[n, 2] - boxes[n, 0]) *
+ *                         (boxes[n, 3] - boxes[n, 1]) +
+ */
+          __pyx_v_ua = ((double)(((((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_40, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_41, __pyx_pybuffernd_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_42, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_43, __pyx_pybuffernd_boxes.diminfo[1].strides))) * ((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_44, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_45, __pyx_pybuffernd_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_46, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_47, __pyx_pybuffernd_boxes.diminfo[1].strides)))) + __pyx_v_box_area) - (__pyx_v_iw * __pyx_v_ih)));
+
+          /* "bbox.pyx":63
+ *                     #         box_area - iw * ih
+ *                     #     )
+ *                     overlaps[n, k] = iw * ih / ua             # <<<<<<<<<<<<<<
+ *     return overlaps
+ * 
+ */
+          __pyx_t_24 = (__pyx_v_iw * __pyx_v_ih);
+          if (unlikely(__pyx_v_ua == 0)) {
+            PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+            __PYX_ERR(0, 63, __pyx_L1_error)
+          }
+          __pyx_t_48 = __pyx_v_n;
+          __pyx_t_49 = __pyx_v_k;
+          __pyx_t_10 = -1;
+          if (unlikely(__pyx_t_48 >= (size_t)__pyx_pybuffernd_overlaps.diminfo[0].shape)) __pyx_t_10 = 0;
+          if (unlikely(__pyx_t_49 >= (size_t)__pyx_pybuffernd_overlaps.diminfo[1].shape)) __pyx_t_10 = 1;
+          if (unlikely(__pyx_t_10 != -1)) {
+            __Pyx_RaiseBufferIndexError(__pyx_t_10);
+            __PYX_ERR(0, 63, __pyx_L1_error)
+          }
+          *__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.buf, __pyx_t_48, __pyx_pybuffernd_overlaps.diminfo[0].strides, __pyx_t_49, __pyx_pybuffernd_overlaps.diminfo[1].strides) = (__pyx_t_24 / __pyx_v_ua);
+
+          /* "bbox.pyx":48
+ *                     max(boxes[n, 1], query_boxes[k, 1])
+ *                 )
+ *                 if ih > 0:             # <<<<<<<<<<<<<<
+ *                     ua = float(
+ *                         (boxes[n, 2] - boxes[n, 0]) *
+ */
+        }
+
+        /* "bbox.pyx":43
+ *                 max(boxes[n, 0], query_boxes[k, 0])
+ *             )
+ *             if iw > 0:             # <<<<<<<<<<<<<<
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -
+ */
+      }
+    }
+  }
+
+  /* "bbox.pyx":64
+ *                     #     )
+ *                     overlaps[n, k] = iw * ih / ua
+ *     return overlaps             # <<<<<<<<<<<<<<
+ * 
+ * def bbox_overlaps(
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_overlaps));
+  __pyx_r = ((PyObject *)__pyx_v_overlaps);
+  goto __pyx_L0;
+
+  /* "bbox.pyx":15
+ * ctypedef np.float_t DTYPE_t
+ * 
+ * def bbox_overlaps_float(             # <<<<<<<<<<<<<<
+ *         np.ndarray[DTYPE_t, ndim=2] boxes,
+ *         np.ndarray[DTYPE_t, ndim=2] query_boxes):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_overlaps.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("cython_bbox.bbox_overlaps_float", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_overlaps.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_overlaps);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "bbox.pyx":66
+ *     return overlaps
+ * 
+ * def bbox_overlaps(             # <<<<<<<<<<<<<<
+ *         np.ndarray[DTYPE_t, ndim=2] boxes,
+ *         np.ndarray[DTYPE_t, ndim=2] query_boxes):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11cython_bbox_3bbox_overlaps(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_11cython_bbox_2bbox_overlaps[] = "\n    Parameters\n    ----------\n    boxes: (N, 4) ndarray of float\n    query_boxes: (K, 4) ndarray of float\n    Returns\n    -------\n    overlaps: (N, K) ndarray of overlap between boxes and query_boxes\n    ";
+static PyMethodDef __pyx_mdef_11cython_bbox_3bbox_overlaps = {"bbox_overlaps", (PyCFunction)__pyx_pw_11cython_bbox_3bbox_overlaps, METH_VARARGS|METH_KEYWORDS, __pyx_doc_11cython_bbox_2bbox_overlaps};
+static PyObject *__pyx_pw_11cython_bbox_3bbox_overlaps(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyArrayObject *__pyx_v_boxes = 0;
+  PyArrayObject *__pyx_v_query_boxes = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("bbox_overlaps (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_boxes,&__pyx_n_s_query_boxes,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_boxes)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_query_boxes)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("bbox_overlaps", 1, 2, 2, 1); __PYX_ERR(0, 66, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "bbox_overlaps") < 0)) __PYX_ERR(0, 66, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_boxes = ((PyArrayObject *)values[0]);
+    __pyx_v_query_boxes = ((PyArrayObject *)values[1]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("bbox_overlaps", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 66, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("cython_bbox.bbox_overlaps", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_boxes), __pyx_ptype_5numpy_ndarray, 1, "boxes", 0))) __PYX_ERR(0, 67, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_query_boxes), __pyx_ptype_5numpy_ndarray, 1, "query_boxes", 0))) __PYX_ERR(0, 68, __pyx_L1_error)
+  __pyx_r = __pyx_pf_11cython_bbox_2bbox_overlaps(__pyx_self, __pyx_v_boxes, __pyx_v_query_boxes);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_11cython_bbox_2bbox_overlaps(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_boxes, PyArrayObject *__pyx_v_query_boxes) {
+  unsigned int __pyx_v_N;
+  unsigned int __pyx_v_K;
+  PyArrayObject *__pyx_v_overlaps = 0;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_v_iw;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_v_ih;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_v_box_area;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_v_ua;
+  unsigned int __pyx_v_k;
+  unsigned int __pyx_v_n;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_boxes;
+  __Pyx_Buffer __pyx_pybuffer_boxes;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_overlaps;
+  __Pyx_Buffer __pyx_pybuffer_overlaps;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_query_boxes;
+  __Pyx_Buffer __pyx_pybuffer_query_boxes;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyArrayObject *__pyx_t_5 = NULL;
+  unsigned int __pyx_t_6;
+  unsigned int __pyx_t_7;
+  size_t __pyx_t_8;
+  Py_ssize_t __pyx_t_9;
+  int __pyx_t_10;
+  size_t __pyx_t_11;
+  Py_ssize_t __pyx_t_12;
+  size_t __pyx_t_13;
+  Py_ssize_t __pyx_t_14;
+  size_t __pyx_t_15;
+  Py_ssize_t __pyx_t_16;
+  unsigned int __pyx_t_17;
+  unsigned int __pyx_t_18;
+  size_t __pyx_t_19;
+  Py_ssize_t __pyx_t_20;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_t_21;
+  size_t __pyx_t_22;
+  Py_ssize_t __pyx_t_23;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_t_24;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_t_25;
+  size_t __pyx_t_26;
+  Py_ssize_t __pyx_t_27;
+  size_t __pyx_t_28;
+  Py_ssize_t __pyx_t_29;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_t_30;
+  int __pyx_t_31;
+  size_t __pyx_t_32;
+  Py_ssize_t __pyx_t_33;
+  size_t __pyx_t_34;
+  Py_ssize_t __pyx_t_35;
+  size_t __pyx_t_36;
+  Py_ssize_t __pyx_t_37;
+  size_t __pyx_t_38;
+  Py_ssize_t __pyx_t_39;
+  size_t __pyx_t_40;
+  Py_ssize_t __pyx_t_41;
+  size_t __pyx_t_42;
+  Py_ssize_t __pyx_t_43;
+  size_t __pyx_t_44;
+  Py_ssize_t __pyx_t_45;
+  size_t __pyx_t_46;
+  Py_ssize_t __pyx_t_47;
+  size_t __pyx_t_48;
+  size_t __pyx_t_49;
+  __Pyx_RefNannySetupContext("bbox_overlaps", 0);
+  __pyx_pybuffer_overlaps.pybuffer.buf = NULL;
+  __pyx_pybuffer_overlaps.refcount = 0;
+  __pyx_pybuffernd_overlaps.data = NULL;
+  __pyx_pybuffernd_overlaps.rcbuffer = &__pyx_pybuffer_overlaps;
+  __pyx_pybuffer_boxes.pybuffer.buf = NULL;
+  __pyx_pybuffer_boxes.refcount = 0;
+  __pyx_pybuffernd_boxes.data = NULL;
+  __pyx_pybuffernd_boxes.rcbuffer = &__pyx_pybuffer_boxes;
+  __pyx_pybuffer_query_boxes.pybuffer.buf = NULL;
+  __pyx_pybuffer_query_boxes.refcount = 0;
+  __pyx_pybuffernd_query_boxes.data = NULL;
+  __pyx_pybuffernd_query_boxes.rcbuffer = &__pyx_pybuffer_query_boxes;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer, (PyObject*)__pyx_v_boxes, &__Pyx_TypeInfo_nn___pyx_t_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 66, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_boxes.diminfo[0].strides = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_boxes.diminfo[0].shape = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_boxes.diminfo[1].strides = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_boxes.diminfo[1].shape = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.shape[1];
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer, (PyObject*)__pyx_v_query_boxes, &__Pyx_TypeInfo_nn___pyx_t_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 66, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_query_boxes.diminfo[0].strides = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_query_boxes.diminfo[0].shape = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_query_boxes.diminfo[1].strides = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_query_boxes.diminfo[1].shape = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.shape[1];
+
+  /* "bbox.pyx":78
+ *     overlaps: (N, K) ndarray of overlap between boxes and query_boxes
+ *     """
+ *     cdef unsigned int N = boxes.shape[0]             # <<<<<<<<<<<<<<
+ *     cdef unsigned int K = query_boxes.shape[0]
+ *     cdef np.ndarray[DTYPE_t, ndim=2] overlaps = np.zeros((N, K), dtype=DTYPE)
+ */
+  __pyx_v_N = (__pyx_v_boxes->dimensions[0]);
+
+  /* "bbox.pyx":79
+ *     """
+ *     cdef unsigned int N = boxes.shape[0]
+ *     cdef unsigned int K = query_boxes.shape[0]             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[DTYPE_t, ndim=2] overlaps = np.zeros((N, K), dtype=DTYPE)
+ *     cdef DTYPE_t iw, ih, box_area
+ */
+  __pyx_v_K = (__pyx_v_query_boxes->dimensions[0]);
+
+  /* "bbox.pyx":80
+ *     cdef unsigned int N = boxes.shape[0]
+ *     cdef unsigned int K = query_boxes.shape[0]
+ *     cdef np.ndarray[DTYPE_t, ndim=2] overlaps = np.zeros((N, K), dtype=DTYPE)             # <<<<<<<<<<<<<<
+ *     cdef DTYPE_t iw, ih, box_area
+ *     cdef DTYPE_t ua
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 80, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_N); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 80, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_K); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 80, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 80, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
+  __pyx_t_1 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 80, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
+  __pyx_t_4 = 0;
+  __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 80, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 80, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 80, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 80, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 80, __pyx_L1_error)
+  __pyx_t_5 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_overlaps.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) {
+      __pyx_v_overlaps = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 80, __pyx_L1_error)
+    } else {__pyx_pybuffernd_overlaps.diminfo[0].strides = __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_overlaps.diminfo[0].shape = __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_overlaps.diminfo[1].strides = __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_overlaps.diminfo[1].shape = __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.shape[1];
+    }
+  }
+  __pyx_t_5 = 0;
+  __pyx_v_overlaps = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "bbox.pyx":84
+ *     cdef DTYPE_t ua
+ *     cdef unsigned int k, n
+ *     for k in range(K):             # <<<<<<<<<<<<<<
+ *         box_area = (
+ *             (query_boxes[k, 2] - query_boxes[k, 0] + 1) *
+ */
+  __pyx_t_6 = __pyx_v_K;
+  for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) {
+    __pyx_v_k = __pyx_t_7;
+
+    /* "bbox.pyx":86
+ *     for k in range(K):
+ *         box_area = (
+ *             (query_boxes[k, 2] - query_boxes[k, 0] + 1) *             # <<<<<<<<<<<<<<
+ *             (query_boxes[k, 3] - query_boxes[k, 1] + 1)
+ *         )
+ */
+    __pyx_t_8 = __pyx_v_k;
+    __pyx_t_9 = 2;
+    __pyx_t_10 = -1;
+    if (unlikely(__pyx_t_8 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+    if (__pyx_t_9 < 0) {
+      __pyx_t_9 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+      if (unlikely(__pyx_t_9 < 0)) __pyx_t_10 = 1;
+    } else if (unlikely(__pyx_t_9 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+    if (unlikely(__pyx_t_10 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_10);
+      __PYX_ERR(0, 86, __pyx_L1_error)
+    }
+    __pyx_t_11 = __pyx_v_k;
+    __pyx_t_12 = 0;
+    __pyx_t_10 = -1;
+    if (unlikely(__pyx_t_11 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+    if (__pyx_t_12 < 0) {
+      __pyx_t_12 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+      if (unlikely(__pyx_t_12 < 0)) __pyx_t_10 = 1;
+    } else if (unlikely(__pyx_t_12 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+    if (unlikely(__pyx_t_10 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_10);
+      __PYX_ERR(0, 86, __pyx_L1_error)
+    }
+
+    /* "bbox.pyx":87
+ *         box_area = (
+ *             (query_boxes[k, 2] - query_boxes[k, 0] + 1) *
+ *             (query_boxes[k, 3] - query_boxes[k, 1] + 1)             # <<<<<<<<<<<<<<
+ *         )
+ *         for n in range(N):
+ */
+    __pyx_t_13 = __pyx_v_k;
+    __pyx_t_14 = 3;
+    __pyx_t_10 = -1;
+    if (unlikely(__pyx_t_13 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+    if (__pyx_t_14 < 0) {
+      __pyx_t_14 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+      if (unlikely(__pyx_t_14 < 0)) __pyx_t_10 = 1;
+    } else if (unlikely(__pyx_t_14 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+    if (unlikely(__pyx_t_10 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_10);
+      __PYX_ERR(0, 87, __pyx_L1_error)
+    }
+    __pyx_t_15 = __pyx_v_k;
+    __pyx_t_16 = 1;
+    __pyx_t_10 = -1;
+    if (unlikely(__pyx_t_15 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+    if (__pyx_t_16 < 0) {
+      __pyx_t_16 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+      if (unlikely(__pyx_t_16 < 0)) __pyx_t_10 = 1;
+    } else if (unlikely(__pyx_t_16 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+    if (unlikely(__pyx_t_10 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_10);
+      __PYX_ERR(0, 87, __pyx_L1_error)
+    }
+
+    /* "bbox.pyx":86
+ *     for k in range(K):
+ *         box_area = (
+ *             (query_boxes[k, 2] - query_boxes[k, 0] + 1) *             # <<<<<<<<<<<<<<
+ *             (query_boxes[k, 3] - query_boxes[k, 1] + 1)
+ *         )
+ */
+    __pyx_v_box_area = ((((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_9, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_11, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_12, __pyx_pybuffernd_query_boxes.diminfo[1].strides))) + 1.0) * (((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_13, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_14, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_16, __pyx_pybuffernd_query_boxes.diminfo[1].strides))) + 1.0));
+
+    /* "bbox.pyx":89
+ *             (query_boxes[k, 3] - query_boxes[k, 1] + 1)
+ *         )
+ *         for n in range(N):             # <<<<<<<<<<<<<<
+ *             iw = (
+ *                 min(boxes[n, 2], query_boxes[k, 2]) -
+ */
+    __pyx_t_17 = __pyx_v_N;
+    for (__pyx_t_18 = 0; __pyx_t_18 < __pyx_t_17; __pyx_t_18+=1) {
+      __pyx_v_n = __pyx_t_18;
+
+      /* "bbox.pyx":91
+ *         for n in range(N):
+ *             iw = (
+ *                 min(boxes[n, 2], query_boxes[k, 2]) -             # <<<<<<<<<<<<<<
+ *                 max(boxes[n, 0], query_boxes[k, 0]) + 1
+ *             )
+ */
+      __pyx_t_19 = __pyx_v_k;
+      __pyx_t_20 = 2;
+      __pyx_t_10 = -1;
+      if (unlikely(__pyx_t_19 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+      if (__pyx_t_20 < 0) {
+        __pyx_t_20 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+        if (unlikely(__pyx_t_20 < 0)) __pyx_t_10 = 1;
+      } else if (unlikely(__pyx_t_20 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+      if (unlikely(__pyx_t_10 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_10);
+        __PYX_ERR(0, 91, __pyx_L1_error)
+      }
+      __pyx_t_21 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_19, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_20, __pyx_pybuffernd_query_boxes.diminfo[1].strides));
+      __pyx_t_22 = __pyx_v_n;
+      __pyx_t_23 = 2;
+      __pyx_t_10 = -1;
+      if (unlikely(__pyx_t_22 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+      if (__pyx_t_23 < 0) {
+        __pyx_t_23 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+        if (unlikely(__pyx_t_23 < 0)) __pyx_t_10 = 1;
+      } else if (unlikely(__pyx_t_23 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+      if (unlikely(__pyx_t_10 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_10);
+        __PYX_ERR(0, 91, __pyx_L1_error)
+      }
+      __pyx_t_24 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_22, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_23, __pyx_pybuffernd_boxes.diminfo[1].strides));
+      if (((__pyx_t_21 < __pyx_t_24) != 0)) {
+        __pyx_t_25 = __pyx_t_21;
+      } else {
+        __pyx_t_25 = __pyx_t_24;
+      }
+
+      /* "bbox.pyx":92
+ *             iw = (
+ *                 min(boxes[n, 2], query_boxes[k, 2]) -
+ *                 max(boxes[n, 0], query_boxes[k, 0]) + 1             # <<<<<<<<<<<<<<
+ *             )
+ *             if iw > 0:
+ */
+      __pyx_t_26 = __pyx_v_k;
+      __pyx_t_27 = 0;
+      __pyx_t_10 = -1;
+      if (unlikely(__pyx_t_26 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+      if (__pyx_t_27 < 0) {
+        __pyx_t_27 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+        if (unlikely(__pyx_t_27 < 0)) __pyx_t_10 = 1;
+      } else if (unlikely(__pyx_t_27 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+      if (unlikely(__pyx_t_10 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_10);
+        __PYX_ERR(0, 92, __pyx_L1_error)
+      }
+      __pyx_t_21 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_26, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_27, __pyx_pybuffernd_query_boxes.diminfo[1].strides));
+      __pyx_t_28 = __pyx_v_n;
+      __pyx_t_29 = 0;
+      __pyx_t_10 = -1;
+      if (unlikely(__pyx_t_28 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+      if (__pyx_t_29 < 0) {
+        __pyx_t_29 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+        if (unlikely(__pyx_t_29 < 0)) __pyx_t_10 = 1;
+      } else if (unlikely(__pyx_t_29 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+      if (unlikely(__pyx_t_10 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_10);
+        __PYX_ERR(0, 92, __pyx_L1_error)
+      }
+      __pyx_t_24 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_28, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_29, __pyx_pybuffernd_boxes.diminfo[1].strides));
+      if (((__pyx_t_21 > __pyx_t_24) != 0)) {
+        __pyx_t_30 = __pyx_t_21;
+      } else {
+        __pyx_t_30 = __pyx_t_24;
+      }
+
+      /* "bbox.pyx":91
+ *         for n in range(N):
+ *             iw = (
+ *                 min(boxes[n, 2], query_boxes[k, 2]) -             # <<<<<<<<<<<<<<
+ *                 max(boxes[n, 0], query_boxes[k, 0]) + 1
+ *             )
+ */
+      __pyx_v_iw = ((__pyx_t_25 - __pyx_t_30) + 1.0);
+
+      /* "bbox.pyx":94
+ *                 max(boxes[n, 0], query_boxes[k, 0]) + 1
+ *             )
+ *             if iw > 0:             # <<<<<<<<<<<<<<
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -
+ */
+      __pyx_t_31 = ((__pyx_v_iw > 0.0) != 0);
+      if (__pyx_t_31) {
+
+        /* "bbox.pyx":96
+ *             if iw > 0:
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -             # <<<<<<<<<<<<<<
+ *                     max(boxes[n, 1], query_boxes[k, 1]) + 1
+ *                 )
+ */
+        __pyx_t_32 = __pyx_v_k;
+        __pyx_t_33 = 3;
+        __pyx_t_10 = -1;
+        if (unlikely(__pyx_t_32 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+        if (__pyx_t_33 < 0) {
+          __pyx_t_33 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+          if (unlikely(__pyx_t_33 < 0)) __pyx_t_10 = 1;
+        } else if (unlikely(__pyx_t_33 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+        if (unlikely(__pyx_t_10 != -1)) {
+          __Pyx_RaiseBufferIndexError(__pyx_t_10);
+          __PYX_ERR(0, 96, __pyx_L1_error)
+        }
+        __pyx_t_30 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_32, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_33, __pyx_pybuffernd_query_boxes.diminfo[1].strides));
+        __pyx_t_34 = __pyx_v_n;
+        __pyx_t_35 = 3;
+        __pyx_t_10 = -1;
+        if (unlikely(__pyx_t_34 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+        if (__pyx_t_35 < 0) {
+          __pyx_t_35 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+          if (unlikely(__pyx_t_35 < 0)) __pyx_t_10 = 1;
+        } else if (unlikely(__pyx_t_35 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+        if (unlikely(__pyx_t_10 != -1)) {
+          __Pyx_RaiseBufferIndexError(__pyx_t_10);
+          __PYX_ERR(0, 96, __pyx_L1_error)
+        }
+        __pyx_t_25 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_34, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_35, __pyx_pybuffernd_boxes.diminfo[1].strides));
+        if (((__pyx_t_30 < __pyx_t_25) != 0)) {
+          __pyx_t_21 = __pyx_t_30;
+        } else {
+          __pyx_t_21 = __pyx_t_25;
+        }
+
+        /* "bbox.pyx":97
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -
+ *                     max(boxes[n, 1], query_boxes[k, 1]) + 1             # <<<<<<<<<<<<<<
+ *                 )
+ *                 if ih > 0:
+ */
+        __pyx_t_36 = __pyx_v_k;
+        __pyx_t_37 = 1;
+        __pyx_t_10 = -1;
+        if (unlikely(__pyx_t_36 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+        if (__pyx_t_37 < 0) {
+          __pyx_t_37 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+          if (unlikely(__pyx_t_37 < 0)) __pyx_t_10 = 1;
+        } else if (unlikely(__pyx_t_37 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+        if (unlikely(__pyx_t_10 != -1)) {
+          __Pyx_RaiseBufferIndexError(__pyx_t_10);
+          __PYX_ERR(0, 97, __pyx_L1_error)
+        }
+        __pyx_t_30 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_36, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_37, __pyx_pybuffernd_query_boxes.diminfo[1].strides));
+        __pyx_t_38 = __pyx_v_n;
+        __pyx_t_39 = 1;
+        __pyx_t_10 = -1;
+        if (unlikely(__pyx_t_38 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+        if (__pyx_t_39 < 0) {
+          __pyx_t_39 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+          if (unlikely(__pyx_t_39 < 0)) __pyx_t_10 = 1;
+        } else if (unlikely(__pyx_t_39 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+        if (unlikely(__pyx_t_10 != -1)) {
+          __Pyx_RaiseBufferIndexError(__pyx_t_10);
+          __PYX_ERR(0, 97, __pyx_L1_error)
+        }
+        __pyx_t_25 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_38, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_39, __pyx_pybuffernd_boxes.diminfo[1].strides));
+        if (((__pyx_t_30 > __pyx_t_25) != 0)) {
+          __pyx_t_24 = __pyx_t_30;
+        } else {
+          __pyx_t_24 = __pyx_t_25;
+        }
+
+        /* "bbox.pyx":96
+ *             if iw > 0:
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -             # <<<<<<<<<<<<<<
+ *                     max(boxes[n, 1], query_boxes[k, 1]) + 1
+ *                 )
+ */
+        __pyx_v_ih = ((__pyx_t_21 - __pyx_t_24) + 1.0);
+
+        /* "bbox.pyx":99
+ *                     max(boxes[n, 1], query_boxes[k, 1]) + 1
+ *                 )
+ *                 if ih > 0:             # <<<<<<<<<<<<<<
+ *                     ua = float(
+ *                         (boxes[n, 2] - boxes[n, 0] + 1) *
+ */
+        __pyx_t_31 = ((__pyx_v_ih > 0.0) != 0);
+        if (__pyx_t_31) {
+
+          /* "bbox.pyx":101
+ *                 if ih > 0:
+ *                     ua = float(
+ *                         (boxes[n, 2] - boxes[n, 0] + 1) *             # <<<<<<<<<<<<<<
+ *                         (boxes[n, 3] - boxes[n, 1] + 1) +
+ *                         box_area - iw * ih
+ */
+          __pyx_t_40 = __pyx_v_n;
+          __pyx_t_41 = 2;
+          __pyx_t_10 = -1;
+          if (unlikely(__pyx_t_40 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+          if (__pyx_t_41 < 0) {
+            __pyx_t_41 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+            if (unlikely(__pyx_t_41 < 0)) __pyx_t_10 = 1;
+          } else if (unlikely(__pyx_t_41 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+          if (unlikely(__pyx_t_10 != -1)) {
+            __Pyx_RaiseBufferIndexError(__pyx_t_10);
+            __PYX_ERR(0, 101, __pyx_L1_error)
+          }
+          __pyx_t_42 = __pyx_v_n;
+          __pyx_t_43 = 0;
+          __pyx_t_10 = -1;
+          if (unlikely(__pyx_t_42 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+          if (__pyx_t_43 < 0) {
+            __pyx_t_43 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+            if (unlikely(__pyx_t_43 < 0)) __pyx_t_10 = 1;
+          } else if (unlikely(__pyx_t_43 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+          if (unlikely(__pyx_t_10 != -1)) {
+            __Pyx_RaiseBufferIndexError(__pyx_t_10);
+            __PYX_ERR(0, 101, __pyx_L1_error)
+          }
+
+          /* "bbox.pyx":102
+ *                     ua = float(
+ *                         (boxes[n, 2] - boxes[n, 0] + 1) *
+ *                         (boxes[n, 3] - boxes[n, 1] + 1) +             # <<<<<<<<<<<<<<
+ *                         box_area - iw * ih
+ *                     )
+ */
+          __pyx_t_44 = __pyx_v_n;
+          __pyx_t_45 = 3;
+          __pyx_t_10 = -1;
+          if (unlikely(__pyx_t_44 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+          if (__pyx_t_45 < 0) {
+            __pyx_t_45 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+            if (unlikely(__pyx_t_45 < 0)) __pyx_t_10 = 1;
+          } else if (unlikely(__pyx_t_45 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+          if (unlikely(__pyx_t_10 != -1)) {
+            __Pyx_RaiseBufferIndexError(__pyx_t_10);
+            __PYX_ERR(0, 102, __pyx_L1_error)
+          }
+          __pyx_t_46 = __pyx_v_n;
+          __pyx_t_47 = 1;
+          __pyx_t_10 = -1;
+          if (unlikely(__pyx_t_46 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+          if (__pyx_t_47 < 0) {
+            __pyx_t_47 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+            if (unlikely(__pyx_t_47 < 0)) __pyx_t_10 = 1;
+          } else if (unlikely(__pyx_t_47 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+          if (unlikely(__pyx_t_10 != -1)) {
+            __Pyx_RaiseBufferIndexError(__pyx_t_10);
+            __PYX_ERR(0, 102, __pyx_L1_error)
+          }
+
+          /* "bbox.pyx":100
+ *                 )
+ *                 if ih > 0:
+ *                     ua = float(             # <<<<<<<<<<<<<<
+ *                         (boxes[n, 2] - boxes[n, 0] + 1) *
+ *                         (boxes[n, 3] - boxes[n, 1] + 1) +
+ */
+          __pyx_v_ua = ((double)((((((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_40, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_41, __pyx_pybuffernd_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_42, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_43, __pyx_pybuffernd_boxes.diminfo[1].strides))) + 1.0) * (((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_44, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_45, __pyx_pybuffernd_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_46, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_47, __pyx_pybuffernd_boxes.diminfo[1].strides))) + 1.0)) + __pyx_v_box_area) - (__pyx_v_iw * __pyx_v_ih)));
+
+          /* "bbox.pyx":105
+ *                         box_area - iw * ih
+ *                     )
+ *                     overlaps[n, k] = iw * ih / ua             # <<<<<<<<<<<<<<
+ *     return overlaps
+ * 
+ */
+          __pyx_t_24 = (__pyx_v_iw * __pyx_v_ih);
+          if (unlikely(__pyx_v_ua == 0)) {
+            PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+            __PYX_ERR(0, 105, __pyx_L1_error)
+          }
+          __pyx_t_48 = __pyx_v_n;
+          __pyx_t_49 = __pyx_v_k;
+          __pyx_t_10 = -1;
+          if (unlikely(__pyx_t_48 >= (size_t)__pyx_pybuffernd_overlaps.diminfo[0].shape)) __pyx_t_10 = 0;
+          if (unlikely(__pyx_t_49 >= (size_t)__pyx_pybuffernd_overlaps.diminfo[1].shape)) __pyx_t_10 = 1;
+          if (unlikely(__pyx_t_10 != -1)) {
+            __Pyx_RaiseBufferIndexError(__pyx_t_10);
+            __PYX_ERR(0, 105, __pyx_L1_error)
+          }
+          *__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.buf, __pyx_t_48, __pyx_pybuffernd_overlaps.diminfo[0].strides, __pyx_t_49, __pyx_pybuffernd_overlaps.diminfo[1].strides) = (__pyx_t_24 / __pyx_v_ua);
+
+          /* "bbox.pyx":99
+ *                     max(boxes[n, 1], query_boxes[k, 1]) + 1
+ *                 )
+ *                 if ih > 0:             # <<<<<<<<<<<<<<
+ *                     ua = float(
+ *                         (boxes[n, 2] - boxes[n, 0] + 1) *
+ */
+        }
+
+        /* "bbox.pyx":94
+ *                 max(boxes[n, 0], query_boxes[k, 0]) + 1
+ *             )
+ *             if iw > 0:             # <<<<<<<<<<<<<<
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -
+ */
+      }
+    }
+  }
+
+  /* "bbox.pyx":106
+ *                     )
+ *                     overlaps[n, k] = iw * ih / ua
+ *     return overlaps             # <<<<<<<<<<<<<<
+ * 
+ * def bbox_overlaps_self(
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_overlaps));
+  __pyx_r = ((PyObject *)__pyx_v_overlaps);
+  goto __pyx_L0;
+
+  /* "bbox.pyx":66
+ *     return overlaps
+ * 
+ * def bbox_overlaps(             # <<<<<<<<<<<<<<
+ *         np.ndarray[DTYPE_t, ndim=2] boxes,
+ *         np.ndarray[DTYPE_t, ndim=2] query_boxes):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_overlaps.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("cython_bbox.bbox_overlaps", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_overlaps.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_overlaps);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "bbox.pyx":108
+ *     return overlaps
+ * 
+ * def bbox_overlaps_self(             # <<<<<<<<<<<<<<
+ *         np.ndarray[DTYPE_t, ndim=2] boxes,
+ *         np.ndarray[DTYPE_t, ndim=2] query_boxes):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11cython_bbox_5bbox_overlaps_self(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_11cython_bbox_4bbox_overlaps_self[] = "\n    Parameters\n    ----------\n    boxes: (N, 4) ndarray of float\n    query_boxes: (K, 4) ndarray of float\n    Returns\n    -------\n    overlaps: (N, K) ndarray of overlap between boxes and query_boxes\n    ";
+static PyMethodDef __pyx_mdef_11cython_bbox_5bbox_overlaps_self = {"bbox_overlaps_self", (PyCFunction)__pyx_pw_11cython_bbox_5bbox_overlaps_self, METH_VARARGS|METH_KEYWORDS, __pyx_doc_11cython_bbox_4bbox_overlaps_self};
+static PyObject *__pyx_pw_11cython_bbox_5bbox_overlaps_self(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyArrayObject *__pyx_v_boxes = 0;
+  PyArrayObject *__pyx_v_query_boxes = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("bbox_overlaps_self (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_boxes,&__pyx_n_s_query_boxes,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_boxes)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_query_boxes)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("bbox_overlaps_self", 1, 2, 2, 1); __PYX_ERR(0, 108, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "bbox_overlaps_self") < 0)) __PYX_ERR(0, 108, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_boxes = ((PyArrayObject *)values[0]);
+    __pyx_v_query_boxes = ((PyArrayObject *)values[1]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("bbox_overlaps_self", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 108, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("cython_bbox.bbox_overlaps_self", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_boxes), __pyx_ptype_5numpy_ndarray, 1, "boxes", 0))) __PYX_ERR(0, 109, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_query_boxes), __pyx_ptype_5numpy_ndarray, 1, "query_boxes", 0))) __PYX_ERR(0, 110, __pyx_L1_error)
+  __pyx_r = __pyx_pf_11cython_bbox_4bbox_overlaps_self(__pyx_self, __pyx_v_boxes, __pyx_v_query_boxes);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_11cython_bbox_4bbox_overlaps_self(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_boxes, PyArrayObject *__pyx_v_query_boxes) {
+  unsigned int __pyx_v_N;
+  unsigned int __pyx_v_K;
+  PyArrayObject *__pyx_v_overlaps = 0;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_v_iw;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_v_ih;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_v_box_area;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_v_ua;
+  unsigned int __pyx_v_k;
+  unsigned int __pyx_v_n;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_boxes;
+  __Pyx_Buffer __pyx_pybuffer_boxes;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_overlaps;
+  __Pyx_Buffer __pyx_pybuffer_overlaps;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_query_boxes;
+  __Pyx_Buffer __pyx_pybuffer_query_boxes;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyArrayObject *__pyx_t_5 = NULL;
+  unsigned int __pyx_t_6;
+  unsigned int __pyx_t_7;
+  size_t __pyx_t_8;
+  Py_ssize_t __pyx_t_9;
+  int __pyx_t_10;
+  size_t __pyx_t_11;
+  Py_ssize_t __pyx_t_12;
+  size_t __pyx_t_13;
+  Py_ssize_t __pyx_t_14;
+  size_t __pyx_t_15;
+  Py_ssize_t __pyx_t_16;
+  unsigned int __pyx_t_17;
+  unsigned int __pyx_t_18;
+  size_t __pyx_t_19;
+  Py_ssize_t __pyx_t_20;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_t_21;
+  size_t __pyx_t_22;
+  Py_ssize_t __pyx_t_23;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_t_24;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_t_25;
+  size_t __pyx_t_26;
+  Py_ssize_t __pyx_t_27;
+  size_t __pyx_t_28;
+  Py_ssize_t __pyx_t_29;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_t_30;
+  int __pyx_t_31;
+  size_t __pyx_t_32;
+  Py_ssize_t __pyx_t_33;
+  size_t __pyx_t_34;
+  Py_ssize_t __pyx_t_35;
+  size_t __pyx_t_36;
+  Py_ssize_t __pyx_t_37;
+  size_t __pyx_t_38;
+  Py_ssize_t __pyx_t_39;
+  size_t __pyx_t_40;
+  size_t __pyx_t_41;
+  __Pyx_RefNannySetupContext("bbox_overlaps_self", 0);
+  __pyx_pybuffer_overlaps.pybuffer.buf = NULL;
+  __pyx_pybuffer_overlaps.refcount = 0;
+  __pyx_pybuffernd_overlaps.data = NULL;
+  __pyx_pybuffernd_overlaps.rcbuffer = &__pyx_pybuffer_overlaps;
+  __pyx_pybuffer_boxes.pybuffer.buf = NULL;
+  __pyx_pybuffer_boxes.refcount = 0;
+  __pyx_pybuffernd_boxes.data = NULL;
+  __pyx_pybuffernd_boxes.rcbuffer = &__pyx_pybuffer_boxes;
+  __pyx_pybuffer_query_boxes.pybuffer.buf = NULL;
+  __pyx_pybuffer_query_boxes.refcount = 0;
+  __pyx_pybuffernd_query_boxes.data = NULL;
+  __pyx_pybuffernd_query_boxes.rcbuffer = &__pyx_pybuffer_query_boxes;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer, (PyObject*)__pyx_v_boxes, &__Pyx_TypeInfo_nn___pyx_t_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 108, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_boxes.diminfo[0].strides = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_boxes.diminfo[0].shape = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_boxes.diminfo[1].strides = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_boxes.diminfo[1].shape = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.shape[1];
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer, (PyObject*)__pyx_v_query_boxes, &__Pyx_TypeInfo_nn___pyx_t_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 108, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_query_boxes.diminfo[0].strides = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_query_boxes.diminfo[0].shape = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_query_boxes.diminfo[1].strides = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_query_boxes.diminfo[1].shape = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.shape[1];
+
+  /* "bbox.pyx":120
+ *     overlaps: (N, K) ndarray of overlap between boxes and query_boxes
+ *     """
+ *     cdef unsigned int N = boxes.shape[0]             # <<<<<<<<<<<<<<
+ *     cdef unsigned int K = query_boxes.shape[0]
+ *     cdef np.ndarray[DTYPE_t, ndim=2] overlaps = np.zeros((N, K), dtype=DTYPE)
+ */
+  __pyx_v_N = (__pyx_v_boxes->dimensions[0]);
+
+  /* "bbox.pyx":121
+ *     """
+ *     cdef unsigned int N = boxes.shape[0]
+ *     cdef unsigned int K = query_boxes.shape[0]             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[DTYPE_t, ndim=2] overlaps = np.zeros((N, K), dtype=DTYPE)
+ *     cdef DTYPE_t iw, ih, box_area
+ */
+  __pyx_v_K = (__pyx_v_query_boxes->dimensions[0]);
+
+  /* "bbox.pyx":122
+ *     cdef unsigned int N = boxes.shape[0]
+ *     cdef unsigned int K = query_boxes.shape[0]
+ *     cdef np.ndarray[DTYPE_t, ndim=2] overlaps = np.zeros((N, K), dtype=DTYPE)             # <<<<<<<<<<<<<<
+ *     cdef DTYPE_t iw, ih, box_area
+ *     cdef DTYPE_t ua
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 122, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_N); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 122, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_K); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 122, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 122, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
+  __pyx_t_1 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 122, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
+  __pyx_t_4 = 0;
+  __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 122, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 122, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 122, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 122, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 122, __pyx_L1_error)
+  __pyx_t_5 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_overlaps.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) {
+      __pyx_v_overlaps = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 122, __pyx_L1_error)
+    } else {__pyx_pybuffernd_overlaps.diminfo[0].strides = __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_overlaps.diminfo[0].shape = __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_overlaps.diminfo[1].strides = __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_overlaps.diminfo[1].shape = __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.shape[1];
+    }
+  }
+  __pyx_t_5 = 0;
+  __pyx_v_overlaps = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "bbox.pyx":126
+ *     cdef DTYPE_t ua
+ *     cdef unsigned int k, n
+ *     for k in range(K):             # <<<<<<<<<<<<<<
+ *         box_area = (
+ *             (query_boxes[k, 2] - query_boxes[k, 0] + 1) *
+ */
+  __pyx_t_6 = __pyx_v_K;
+  for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) {
+    __pyx_v_k = __pyx_t_7;
+
+    /* "bbox.pyx":128
+ *     for k in range(K):
+ *         box_area = (
+ *             (query_boxes[k, 2] - query_boxes[k, 0] + 1) *             # <<<<<<<<<<<<<<
+ *             (query_boxes[k, 3] - query_boxes[k, 1] + 1)
+ *         )
+ */
+    __pyx_t_8 = __pyx_v_k;
+    __pyx_t_9 = 2;
+    __pyx_t_10 = -1;
+    if (unlikely(__pyx_t_8 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+    if (__pyx_t_9 < 0) {
+      __pyx_t_9 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+      if (unlikely(__pyx_t_9 < 0)) __pyx_t_10 = 1;
+    } else if (unlikely(__pyx_t_9 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+    if (unlikely(__pyx_t_10 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_10);
+      __PYX_ERR(0, 128, __pyx_L1_error)
+    }
+    __pyx_t_11 = __pyx_v_k;
+    __pyx_t_12 = 0;
+    __pyx_t_10 = -1;
+    if (unlikely(__pyx_t_11 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+    if (__pyx_t_12 < 0) {
+      __pyx_t_12 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+      if (unlikely(__pyx_t_12 < 0)) __pyx_t_10 = 1;
+    } else if (unlikely(__pyx_t_12 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+    if (unlikely(__pyx_t_10 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_10);
+      __PYX_ERR(0, 128, __pyx_L1_error)
+    }
+
+    /* "bbox.pyx":129
+ *         box_area = (
+ *             (query_boxes[k, 2] - query_boxes[k, 0] + 1) *
+ *             (query_boxes[k, 3] - query_boxes[k, 1] + 1)             # <<<<<<<<<<<<<<
+ *         )
+ *         for n in range(N):
+ */
+    __pyx_t_13 = __pyx_v_k;
+    __pyx_t_14 = 3;
+    __pyx_t_10 = -1;
+    if (unlikely(__pyx_t_13 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+    if (__pyx_t_14 < 0) {
+      __pyx_t_14 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+      if (unlikely(__pyx_t_14 < 0)) __pyx_t_10 = 1;
+    } else if (unlikely(__pyx_t_14 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+    if (unlikely(__pyx_t_10 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_10);
+      __PYX_ERR(0, 129, __pyx_L1_error)
+    }
+    __pyx_t_15 = __pyx_v_k;
+    __pyx_t_16 = 1;
+    __pyx_t_10 = -1;
+    if (unlikely(__pyx_t_15 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+    if (__pyx_t_16 < 0) {
+      __pyx_t_16 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+      if (unlikely(__pyx_t_16 < 0)) __pyx_t_10 = 1;
+    } else if (unlikely(__pyx_t_16 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+    if (unlikely(__pyx_t_10 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_10);
+      __PYX_ERR(0, 129, __pyx_L1_error)
+    }
+
+    /* "bbox.pyx":128
+ *     for k in range(K):
+ *         box_area = (
+ *             (query_boxes[k, 2] - query_boxes[k, 0] + 1) *             # <<<<<<<<<<<<<<
+ *             (query_boxes[k, 3] - query_boxes[k, 1] + 1)
+ *         )
+ */
+    __pyx_v_box_area = ((((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_9, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_11, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_12, __pyx_pybuffernd_query_boxes.diminfo[1].strides))) + 1.0) * (((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_13, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_14, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_16, __pyx_pybuffernd_query_boxes.diminfo[1].strides))) + 1.0));
+
+    /* "bbox.pyx":131
+ *             (query_boxes[k, 3] - query_boxes[k, 1] + 1)
+ *         )
+ *         for n in range(N):             # <<<<<<<<<<<<<<
+ *             iw = (
+ *                 min(boxes[n, 2], query_boxes[k, 2]) -
+ */
+    __pyx_t_17 = __pyx_v_N;
+    for (__pyx_t_18 = 0; __pyx_t_18 < __pyx_t_17; __pyx_t_18+=1) {
+      __pyx_v_n = __pyx_t_18;
+
+      /* "bbox.pyx":133
+ *         for n in range(N):
+ *             iw = (
+ *                 min(boxes[n, 2], query_boxes[k, 2]) -             # <<<<<<<<<<<<<<
+ *                 max(boxes[n, 0], query_boxes[k, 0]) + 1
+ *             )
+ */
+      __pyx_t_19 = __pyx_v_k;
+      __pyx_t_20 = 2;
+      __pyx_t_10 = -1;
+      if (unlikely(__pyx_t_19 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+      if (__pyx_t_20 < 0) {
+        __pyx_t_20 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+        if (unlikely(__pyx_t_20 < 0)) __pyx_t_10 = 1;
+      } else if (unlikely(__pyx_t_20 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+      if (unlikely(__pyx_t_10 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_10);
+        __PYX_ERR(0, 133, __pyx_L1_error)
+      }
+      __pyx_t_21 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_19, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_20, __pyx_pybuffernd_query_boxes.diminfo[1].strides));
+      __pyx_t_22 = __pyx_v_n;
+      __pyx_t_23 = 2;
+      __pyx_t_10 = -1;
+      if (unlikely(__pyx_t_22 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+      if (__pyx_t_23 < 0) {
+        __pyx_t_23 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+        if (unlikely(__pyx_t_23 < 0)) __pyx_t_10 = 1;
+      } else if (unlikely(__pyx_t_23 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+      if (unlikely(__pyx_t_10 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_10);
+        __PYX_ERR(0, 133, __pyx_L1_error)
+      }
+      __pyx_t_24 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_22, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_23, __pyx_pybuffernd_boxes.diminfo[1].strides));
+      if (((__pyx_t_21 < __pyx_t_24) != 0)) {
+        __pyx_t_25 = __pyx_t_21;
+      } else {
+        __pyx_t_25 = __pyx_t_24;
+      }
+
+      /* "bbox.pyx":134
+ *             iw = (
+ *                 min(boxes[n, 2], query_boxes[k, 2]) -
+ *                 max(boxes[n, 0], query_boxes[k, 0]) + 1             # <<<<<<<<<<<<<<
+ *             )
+ *             if iw > 0:
+ */
+      __pyx_t_26 = __pyx_v_k;
+      __pyx_t_27 = 0;
+      __pyx_t_10 = -1;
+      if (unlikely(__pyx_t_26 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+      if (__pyx_t_27 < 0) {
+        __pyx_t_27 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+        if (unlikely(__pyx_t_27 < 0)) __pyx_t_10 = 1;
+      } else if (unlikely(__pyx_t_27 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+      if (unlikely(__pyx_t_10 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_10);
+        __PYX_ERR(0, 134, __pyx_L1_error)
+      }
+      __pyx_t_21 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_26, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_27, __pyx_pybuffernd_query_boxes.diminfo[1].strides));
+      __pyx_t_28 = __pyx_v_n;
+      __pyx_t_29 = 0;
+      __pyx_t_10 = -1;
+      if (unlikely(__pyx_t_28 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+      if (__pyx_t_29 < 0) {
+        __pyx_t_29 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+        if (unlikely(__pyx_t_29 < 0)) __pyx_t_10 = 1;
+      } else if (unlikely(__pyx_t_29 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+      if (unlikely(__pyx_t_10 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_10);
+        __PYX_ERR(0, 134, __pyx_L1_error)
+      }
+      __pyx_t_24 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_28, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_29, __pyx_pybuffernd_boxes.diminfo[1].strides));
+      if (((__pyx_t_21 > __pyx_t_24) != 0)) {
+        __pyx_t_30 = __pyx_t_21;
+      } else {
+        __pyx_t_30 = __pyx_t_24;
+      }
+
+      /* "bbox.pyx":133
+ *         for n in range(N):
+ *             iw = (
+ *                 min(boxes[n, 2], query_boxes[k, 2]) -             # <<<<<<<<<<<<<<
+ *                 max(boxes[n, 0], query_boxes[k, 0]) + 1
+ *             )
+ */
+      __pyx_v_iw = ((__pyx_t_25 - __pyx_t_30) + 1.0);
+
+      /* "bbox.pyx":136
+ *                 max(boxes[n, 0], query_boxes[k, 0]) + 1
+ *             )
+ *             if iw > 0:             # <<<<<<<<<<<<<<
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -
+ */
+      __pyx_t_31 = ((__pyx_v_iw > 0.0) != 0);
+      if (__pyx_t_31) {
+
+        /* "bbox.pyx":138
+ *             if iw > 0:
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -             # <<<<<<<<<<<<<<
+ *                     max(boxes[n, 1], query_boxes[k, 1]) + 1
+ *                 )
+ */
+        __pyx_t_32 = __pyx_v_k;
+        __pyx_t_33 = 3;
+        __pyx_t_10 = -1;
+        if (unlikely(__pyx_t_32 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+        if (__pyx_t_33 < 0) {
+          __pyx_t_33 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+          if (unlikely(__pyx_t_33 < 0)) __pyx_t_10 = 1;
+        } else if (unlikely(__pyx_t_33 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+        if (unlikely(__pyx_t_10 != -1)) {
+          __Pyx_RaiseBufferIndexError(__pyx_t_10);
+          __PYX_ERR(0, 138, __pyx_L1_error)
+        }
+        __pyx_t_30 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_32, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_33, __pyx_pybuffernd_query_boxes.diminfo[1].strides));
+        __pyx_t_34 = __pyx_v_n;
+        __pyx_t_35 = 3;
+        __pyx_t_10 = -1;
+        if (unlikely(__pyx_t_34 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+        if (__pyx_t_35 < 0) {
+          __pyx_t_35 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+          if (unlikely(__pyx_t_35 < 0)) __pyx_t_10 = 1;
+        } else if (unlikely(__pyx_t_35 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+        if (unlikely(__pyx_t_10 != -1)) {
+          __Pyx_RaiseBufferIndexError(__pyx_t_10);
+          __PYX_ERR(0, 138, __pyx_L1_error)
+        }
+        __pyx_t_25 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_34, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_35, __pyx_pybuffernd_boxes.diminfo[1].strides));
+        if (((__pyx_t_30 < __pyx_t_25) != 0)) {
+          __pyx_t_21 = __pyx_t_30;
+        } else {
+          __pyx_t_21 = __pyx_t_25;
+        }
+
+        /* "bbox.pyx":139
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -
+ *                     max(boxes[n, 1], query_boxes[k, 1]) + 1             # <<<<<<<<<<<<<<
+ *                 )
+ *                 if ih > 0:
+ */
+        __pyx_t_36 = __pyx_v_k;
+        __pyx_t_37 = 1;
+        __pyx_t_10 = -1;
+        if (unlikely(__pyx_t_36 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+        if (__pyx_t_37 < 0) {
+          __pyx_t_37 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+          if (unlikely(__pyx_t_37 < 0)) __pyx_t_10 = 1;
+        } else if (unlikely(__pyx_t_37 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+        if (unlikely(__pyx_t_10 != -1)) {
+          __Pyx_RaiseBufferIndexError(__pyx_t_10);
+          __PYX_ERR(0, 139, __pyx_L1_error)
+        }
+        __pyx_t_30 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_36, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_37, __pyx_pybuffernd_query_boxes.diminfo[1].strides));
+        __pyx_t_38 = __pyx_v_n;
+        __pyx_t_39 = 1;
+        __pyx_t_10 = -1;
+        if (unlikely(__pyx_t_38 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+        if (__pyx_t_39 < 0) {
+          __pyx_t_39 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+          if (unlikely(__pyx_t_39 < 0)) __pyx_t_10 = 1;
+        } else if (unlikely(__pyx_t_39 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+        if (unlikely(__pyx_t_10 != -1)) {
+          __Pyx_RaiseBufferIndexError(__pyx_t_10);
+          __PYX_ERR(0, 139, __pyx_L1_error)
+        }
+        __pyx_t_25 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_38, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_39, __pyx_pybuffernd_boxes.diminfo[1].strides));
+        if (((__pyx_t_30 > __pyx_t_25) != 0)) {
+          __pyx_t_24 = __pyx_t_30;
+        } else {
+          __pyx_t_24 = __pyx_t_25;
+        }
+
+        /* "bbox.pyx":138
+ *             if iw > 0:
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -             # <<<<<<<<<<<<<<
+ *                     max(boxes[n, 1], query_boxes[k, 1]) + 1
+ *                 )
+ */
+        __pyx_v_ih = ((__pyx_t_21 - __pyx_t_24) + 1.0);
+
+        /* "bbox.pyx":141
+ *                     max(boxes[n, 1], query_boxes[k, 1]) + 1
+ *                 )
+ *                 if ih > 0:             # <<<<<<<<<<<<<<
+ *                     ua = float(box_area)
+ *                     overlaps[n, k] = iw * ih / ua
+ */
+        __pyx_t_31 = ((__pyx_v_ih > 0.0) != 0);
+        if (__pyx_t_31) {
+
+          /* "bbox.pyx":142
+ *                 )
+ *                 if ih > 0:
+ *                     ua = float(box_area)             # <<<<<<<<<<<<<<
+ *                     overlaps[n, k] = iw * ih / ua
+ *     return overlaps
+ */
+          __pyx_v_ua = ((double)__pyx_v_box_area);
+
+          /* "bbox.pyx":143
+ *                 if ih > 0:
+ *                     ua = float(box_area)
+ *                     overlaps[n, k] = iw * ih / ua             # <<<<<<<<<<<<<<
+ *     return overlaps
+ * 
+ */
+          __pyx_t_24 = (__pyx_v_iw * __pyx_v_ih);
+          if (unlikely(__pyx_v_ua == 0)) {
+            PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+            __PYX_ERR(0, 143, __pyx_L1_error)
+          }
+          __pyx_t_40 = __pyx_v_n;
+          __pyx_t_41 = __pyx_v_k;
+          __pyx_t_10 = -1;
+          if (unlikely(__pyx_t_40 >= (size_t)__pyx_pybuffernd_overlaps.diminfo[0].shape)) __pyx_t_10 = 0;
+          if (unlikely(__pyx_t_41 >= (size_t)__pyx_pybuffernd_overlaps.diminfo[1].shape)) __pyx_t_10 = 1;
+          if (unlikely(__pyx_t_10 != -1)) {
+            __Pyx_RaiseBufferIndexError(__pyx_t_10);
+            __PYX_ERR(0, 143, __pyx_L1_error)
+          }
+          *__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.buf, __pyx_t_40, __pyx_pybuffernd_overlaps.diminfo[0].strides, __pyx_t_41, __pyx_pybuffernd_overlaps.diminfo[1].strides) = (__pyx_t_24 / __pyx_v_ua);
+
+          /* "bbox.pyx":141
+ *                     max(boxes[n, 1], query_boxes[k, 1]) + 1
+ *                 )
+ *                 if ih > 0:             # <<<<<<<<<<<<<<
+ *                     ua = float(box_area)
+ *                     overlaps[n, k] = iw * ih / ua
+ */
+        }
+
+        /* "bbox.pyx":136
+ *                 max(boxes[n, 0], query_boxes[k, 0]) + 1
+ *             )
+ *             if iw > 0:             # <<<<<<<<<<<<<<
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -
+ */
+      }
+    }
+  }
+
+  /* "bbox.pyx":144
+ *                     ua = float(box_area)
+ *                     overlaps[n, k] = iw * ih / ua
+ *     return overlaps             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_overlaps));
+  __pyx_r = ((PyObject *)__pyx_v_overlaps);
+  goto __pyx_L0;
+
+  /* "bbox.pyx":108
+ *     return overlaps
+ * 
+ * def bbox_overlaps_self(             # <<<<<<<<<<<<<<
+ *         np.ndarray[DTYPE_t, ndim=2] boxes,
+ *         np.ndarray[DTYPE_t, ndim=2] query_boxes):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_overlaps.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("cython_bbox.bbox_overlaps_self", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_overlaps.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_overlaps);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "bbox.pyx":147
+ * 
+ * 
+ * def bbox_overlaps_ignore(             # <<<<<<<<<<<<<<
+ *         np.ndarray[DTYPE_t, ndim=2] boxes,
+ *         np.ndarray[DTYPE_t, ndim=2] query_boxes):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11cython_bbox_7bbox_overlaps_ignore(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_11cython_bbox_6bbox_overlaps_ignore[] = "\n    Parameters\n    ----------\n    boxes: (N, 4) ndarray of float\n    query_boxes: (K, 4) ndarray of float\n    Returns\n    -------\n    overlaps: (N, K) ndarray of overlap between boxes and query_boxes\n    ";
+static PyMethodDef __pyx_mdef_11cython_bbox_7bbox_overlaps_ignore = {"bbox_overlaps_ignore", (PyCFunction)__pyx_pw_11cython_bbox_7bbox_overlaps_ignore, METH_VARARGS|METH_KEYWORDS, __pyx_doc_11cython_bbox_6bbox_overlaps_ignore};
+static PyObject *__pyx_pw_11cython_bbox_7bbox_overlaps_ignore(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyArrayObject *__pyx_v_boxes = 0;
+  PyArrayObject *__pyx_v_query_boxes = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("bbox_overlaps_ignore (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_boxes,&__pyx_n_s_query_boxes,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_boxes)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_query_boxes)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("bbox_overlaps_ignore", 1, 2, 2, 1); __PYX_ERR(0, 147, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "bbox_overlaps_ignore") < 0)) __PYX_ERR(0, 147, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_boxes = ((PyArrayObject *)values[0]);
+    __pyx_v_query_boxes = ((PyArrayObject *)values[1]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("bbox_overlaps_ignore", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 147, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("cython_bbox.bbox_overlaps_ignore", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_boxes), __pyx_ptype_5numpy_ndarray, 1, "boxes", 0))) __PYX_ERR(0, 148, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_query_boxes), __pyx_ptype_5numpy_ndarray, 1, "query_boxes", 0))) __PYX_ERR(0, 149, __pyx_L1_error)
+  __pyx_r = __pyx_pf_11cython_bbox_6bbox_overlaps_ignore(__pyx_self, __pyx_v_boxes, __pyx_v_query_boxes);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_11cython_bbox_6bbox_overlaps_ignore(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_boxes, PyArrayObject *__pyx_v_query_boxes) {
+  unsigned int __pyx_v_N;
+  unsigned int __pyx_v_K;
+  PyArrayObject *__pyx_v_overlaps = 0;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_v_iw;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_v_ih;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_v_box_area;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_v_ua;
+  unsigned int __pyx_v_k;
+  unsigned int __pyx_v_n;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_boxes;
+  __Pyx_Buffer __pyx_pybuffer_boxes;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_overlaps;
+  __Pyx_Buffer __pyx_pybuffer_overlaps;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_query_boxes;
+  __Pyx_Buffer __pyx_pybuffer_query_boxes;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyArrayObject *__pyx_t_5 = NULL;
+  unsigned int __pyx_t_6;
+  unsigned int __pyx_t_7;
+  size_t __pyx_t_8;
+  Py_ssize_t __pyx_t_9;
+  int __pyx_t_10;
+  size_t __pyx_t_11;
+  Py_ssize_t __pyx_t_12;
+  size_t __pyx_t_13;
+  Py_ssize_t __pyx_t_14;
+  size_t __pyx_t_15;
+  Py_ssize_t __pyx_t_16;
+  unsigned int __pyx_t_17;
+  unsigned int __pyx_t_18;
+  size_t __pyx_t_19;
+  Py_ssize_t __pyx_t_20;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_t_21;
+  size_t __pyx_t_22;
+  Py_ssize_t __pyx_t_23;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_t_24;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_t_25;
+  size_t __pyx_t_26;
+  Py_ssize_t __pyx_t_27;
+  size_t __pyx_t_28;
+  Py_ssize_t __pyx_t_29;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_t_30;
+  int __pyx_t_31;
+  size_t __pyx_t_32;
+  Py_ssize_t __pyx_t_33;
+  size_t __pyx_t_34;
+  Py_ssize_t __pyx_t_35;
+  size_t __pyx_t_36;
+  Py_ssize_t __pyx_t_37;
+  size_t __pyx_t_38;
+  Py_ssize_t __pyx_t_39;
+  size_t __pyx_t_40;
+  Py_ssize_t __pyx_t_41;
+  size_t __pyx_t_42;
+  Py_ssize_t __pyx_t_43;
+  size_t __pyx_t_44;
+  Py_ssize_t __pyx_t_45;
+  size_t __pyx_t_46;
+  Py_ssize_t __pyx_t_47;
+  size_t __pyx_t_48;
+  Py_ssize_t __pyx_t_49;
+  size_t __pyx_t_50;
+  Py_ssize_t __pyx_t_51;
+  size_t __pyx_t_52;
+  Py_ssize_t __pyx_t_53;
+  size_t __pyx_t_54;
+  Py_ssize_t __pyx_t_55;
+  size_t __pyx_t_56;
+  Py_ssize_t __pyx_t_57;
+  size_t __pyx_t_58;
+  size_t __pyx_t_59;
+  __Pyx_RefNannySetupContext("bbox_overlaps_ignore", 0);
+  __pyx_pybuffer_overlaps.pybuffer.buf = NULL;
+  __pyx_pybuffer_overlaps.refcount = 0;
+  __pyx_pybuffernd_overlaps.data = NULL;
+  __pyx_pybuffernd_overlaps.rcbuffer = &__pyx_pybuffer_overlaps;
+  __pyx_pybuffer_boxes.pybuffer.buf = NULL;
+  __pyx_pybuffer_boxes.refcount = 0;
+  __pyx_pybuffernd_boxes.data = NULL;
+  __pyx_pybuffernd_boxes.rcbuffer = &__pyx_pybuffer_boxes;
+  __pyx_pybuffer_query_boxes.pybuffer.buf = NULL;
+  __pyx_pybuffer_query_boxes.refcount = 0;
+  __pyx_pybuffernd_query_boxes.data = NULL;
+  __pyx_pybuffernd_query_boxes.rcbuffer = &__pyx_pybuffer_query_boxes;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer, (PyObject*)__pyx_v_boxes, &__Pyx_TypeInfo_nn___pyx_t_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 147, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_boxes.diminfo[0].strides = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_boxes.diminfo[0].shape = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_boxes.diminfo[1].strides = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_boxes.diminfo[1].shape = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.shape[1];
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer, (PyObject*)__pyx_v_query_boxes, &__Pyx_TypeInfo_nn___pyx_t_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 147, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_query_boxes.diminfo[0].strides = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_query_boxes.diminfo[0].shape = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_query_boxes.diminfo[1].strides = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_query_boxes.diminfo[1].shape = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.shape[1];
+
+  /* "bbox.pyx":159
+ *     overlaps: (N, K) ndarray of overlap between boxes and query_boxes
+ *     """
+ *     cdef unsigned int N = boxes.shape[0]             # <<<<<<<<<<<<<<
+ *     cdef unsigned int K = query_boxes.shape[0]
+ *     cdef np.ndarray[DTYPE_t, ndim=2] overlaps = np.zeros((N, K), dtype=DTYPE)
+ */
+  __pyx_v_N = (__pyx_v_boxes->dimensions[0]);
+
+  /* "bbox.pyx":160
+ *     """
+ *     cdef unsigned int N = boxes.shape[0]
+ *     cdef unsigned int K = query_boxes.shape[0]             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[DTYPE_t, ndim=2] overlaps = np.zeros((N, K), dtype=DTYPE)
+ *     cdef DTYPE_t iw, ih, box_area
+ */
+  __pyx_v_K = (__pyx_v_query_boxes->dimensions[0]);
+
+  /* "bbox.pyx":161
+ *     cdef unsigned int N = boxes.shape[0]
+ *     cdef unsigned int K = query_boxes.shape[0]
+ *     cdef np.ndarray[DTYPE_t, ndim=2] overlaps = np.zeros((N, K), dtype=DTYPE)             # <<<<<<<<<<<<<<
+ *     cdef DTYPE_t iw, ih, box_area
+ *     cdef DTYPE_t ua
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 161, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 161, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_N); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 161, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_K); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 161, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 161, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
+  __pyx_t_1 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 161, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
+  __pyx_t_4 = 0;
+  __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 161, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 161, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 161, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 161, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 161, __pyx_L1_error)
+  __pyx_t_5 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_overlaps.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) {
+      __pyx_v_overlaps = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 161, __pyx_L1_error)
+    } else {__pyx_pybuffernd_overlaps.diminfo[0].strides = __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_overlaps.diminfo[0].shape = __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_overlaps.diminfo[1].strides = __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_overlaps.diminfo[1].shape = __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.shape[1];
+    }
+  }
+  __pyx_t_5 = 0;
+  __pyx_v_overlaps = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "bbox.pyx":165
+ *     cdef DTYPE_t ua
+ *     cdef unsigned int k, n
+ *     for k in range(K):             # <<<<<<<<<<<<<<
+ *         box_area = (
+ *             (query_boxes[k, 2] - query_boxes[k, 0] + 1) *
+ */
+  __pyx_t_6 = __pyx_v_K;
+  for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) {
+    __pyx_v_k = __pyx_t_7;
+
+    /* "bbox.pyx":167
+ *     for k in range(K):
+ *         box_area = (
+ *             (query_boxes[k, 2] - query_boxes[k, 0] + 1) *             # <<<<<<<<<<<<<<
+ *             (query_boxes[k, 3] - query_boxes[k, 1] + 1)
+ *         )
+ */
+    __pyx_t_8 = __pyx_v_k;
+    __pyx_t_9 = 2;
+    __pyx_t_10 = -1;
+    if (unlikely(__pyx_t_8 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+    if (__pyx_t_9 < 0) {
+      __pyx_t_9 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+      if (unlikely(__pyx_t_9 < 0)) __pyx_t_10 = 1;
+    } else if (unlikely(__pyx_t_9 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+    if (unlikely(__pyx_t_10 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_10);
+      __PYX_ERR(0, 167, __pyx_L1_error)
+    }
+    __pyx_t_11 = __pyx_v_k;
+    __pyx_t_12 = 0;
+    __pyx_t_10 = -1;
+    if (unlikely(__pyx_t_11 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+    if (__pyx_t_12 < 0) {
+      __pyx_t_12 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+      if (unlikely(__pyx_t_12 < 0)) __pyx_t_10 = 1;
+    } else if (unlikely(__pyx_t_12 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+    if (unlikely(__pyx_t_10 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_10);
+      __PYX_ERR(0, 167, __pyx_L1_error)
+    }
+
+    /* "bbox.pyx":168
+ *         box_area = (
+ *             (query_boxes[k, 2] - query_boxes[k, 0] + 1) *
+ *             (query_boxes[k, 3] - query_boxes[k, 1] + 1)             # <<<<<<<<<<<<<<
+ *         )
+ *         for n in range(N):
+ */
+    __pyx_t_13 = __pyx_v_k;
+    __pyx_t_14 = 3;
+    __pyx_t_10 = -1;
+    if (unlikely(__pyx_t_13 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+    if (__pyx_t_14 < 0) {
+      __pyx_t_14 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+      if (unlikely(__pyx_t_14 < 0)) __pyx_t_10 = 1;
+    } else if (unlikely(__pyx_t_14 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+    if (unlikely(__pyx_t_10 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_10);
+      __PYX_ERR(0, 168, __pyx_L1_error)
+    }
+    __pyx_t_15 = __pyx_v_k;
+    __pyx_t_16 = 1;
+    __pyx_t_10 = -1;
+    if (unlikely(__pyx_t_15 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+    if (__pyx_t_16 < 0) {
+      __pyx_t_16 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+      if (unlikely(__pyx_t_16 < 0)) __pyx_t_10 = 1;
+    } else if (unlikely(__pyx_t_16 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+    if (unlikely(__pyx_t_10 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_10);
+      __PYX_ERR(0, 168, __pyx_L1_error)
+    }
+
+    /* "bbox.pyx":167
+ *     for k in range(K):
+ *         box_area = (
+ *             (query_boxes[k, 2] - query_boxes[k, 0] + 1) *             # <<<<<<<<<<<<<<
+ *             (query_boxes[k, 3] - query_boxes[k, 1] + 1)
+ *         )
+ */
+    __pyx_v_box_area = ((((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_9, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_11, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_12, __pyx_pybuffernd_query_boxes.diminfo[1].strides))) + 1.0) * (((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_13, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_14, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_16, __pyx_pybuffernd_query_boxes.diminfo[1].strides))) + 1.0));
+
+    /* "bbox.pyx":170
+ *             (query_boxes[k, 3] - query_boxes[k, 1] + 1)
+ *         )
+ *         for n in range(N):             # <<<<<<<<<<<<<<
+ *             iw = (
+ *                 min(boxes[n, 2], query_boxes[k, 2]) -
+ */
+    __pyx_t_17 = __pyx_v_N;
+    for (__pyx_t_18 = 0; __pyx_t_18 < __pyx_t_17; __pyx_t_18+=1) {
+      __pyx_v_n = __pyx_t_18;
+
+      /* "bbox.pyx":172
+ *         for n in range(N):
+ *             iw = (
+ *                 min(boxes[n, 2], query_boxes[k, 2]) -             # <<<<<<<<<<<<<<
+ *                 max(boxes[n, 0], query_boxes[k, 0]) + 1
+ *             )
+ */
+      __pyx_t_19 = __pyx_v_k;
+      __pyx_t_20 = 2;
+      __pyx_t_10 = -1;
+      if (unlikely(__pyx_t_19 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+      if (__pyx_t_20 < 0) {
+        __pyx_t_20 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+        if (unlikely(__pyx_t_20 < 0)) __pyx_t_10 = 1;
+      } else if (unlikely(__pyx_t_20 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+      if (unlikely(__pyx_t_10 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_10);
+        __PYX_ERR(0, 172, __pyx_L1_error)
+      }
+      __pyx_t_21 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_19, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_20, __pyx_pybuffernd_query_boxes.diminfo[1].strides));
+      __pyx_t_22 = __pyx_v_n;
+      __pyx_t_23 = 2;
+      __pyx_t_10 = -1;
+      if (unlikely(__pyx_t_22 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+      if (__pyx_t_23 < 0) {
+        __pyx_t_23 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+        if (unlikely(__pyx_t_23 < 0)) __pyx_t_10 = 1;
+      } else if (unlikely(__pyx_t_23 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+      if (unlikely(__pyx_t_10 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_10);
+        __PYX_ERR(0, 172, __pyx_L1_error)
+      }
+      __pyx_t_24 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_22, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_23, __pyx_pybuffernd_boxes.diminfo[1].strides));
+      if (((__pyx_t_21 < __pyx_t_24) != 0)) {
+        __pyx_t_25 = __pyx_t_21;
+      } else {
+        __pyx_t_25 = __pyx_t_24;
+      }
+
+      /* "bbox.pyx":173
+ *             iw = (
+ *                 min(boxes[n, 2], query_boxes[k, 2]) -
+ *                 max(boxes[n, 0], query_boxes[k, 0]) + 1             # <<<<<<<<<<<<<<
+ *             )
+ *             if iw > 0:
+ */
+      __pyx_t_26 = __pyx_v_k;
+      __pyx_t_27 = 0;
+      __pyx_t_10 = -1;
+      if (unlikely(__pyx_t_26 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+      if (__pyx_t_27 < 0) {
+        __pyx_t_27 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+        if (unlikely(__pyx_t_27 < 0)) __pyx_t_10 = 1;
+      } else if (unlikely(__pyx_t_27 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+      if (unlikely(__pyx_t_10 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_10);
+        __PYX_ERR(0, 173, __pyx_L1_error)
+      }
+      __pyx_t_21 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_26, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_27, __pyx_pybuffernd_query_boxes.diminfo[1].strides));
+      __pyx_t_28 = __pyx_v_n;
+      __pyx_t_29 = 0;
+      __pyx_t_10 = -1;
+      if (unlikely(__pyx_t_28 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+      if (__pyx_t_29 < 0) {
+        __pyx_t_29 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+        if (unlikely(__pyx_t_29 < 0)) __pyx_t_10 = 1;
+      } else if (unlikely(__pyx_t_29 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+      if (unlikely(__pyx_t_10 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_10);
+        __PYX_ERR(0, 173, __pyx_L1_error)
+      }
+      __pyx_t_24 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_28, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_29, __pyx_pybuffernd_boxes.diminfo[1].strides));
+      if (((__pyx_t_21 > __pyx_t_24) != 0)) {
+        __pyx_t_30 = __pyx_t_21;
+      } else {
+        __pyx_t_30 = __pyx_t_24;
+      }
+
+      /* "bbox.pyx":172
+ *         for n in range(N):
+ *             iw = (
+ *                 min(boxes[n, 2], query_boxes[k, 2]) -             # <<<<<<<<<<<<<<
+ *                 max(boxes[n, 0], query_boxes[k, 0]) + 1
+ *             )
+ */
+      __pyx_v_iw = ((__pyx_t_25 - __pyx_t_30) + 1.0);
+
+      /* "bbox.pyx":175
+ *                 max(boxes[n, 0], query_boxes[k, 0]) + 1
+ *             )
+ *             if iw > 0:             # <<<<<<<<<<<<<<
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -
+ */
+      __pyx_t_31 = ((__pyx_v_iw > 0.0) != 0);
+      if (__pyx_t_31) {
+
+        /* "bbox.pyx":177
+ *             if iw > 0:
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -             # <<<<<<<<<<<<<<
+ *                     max(boxes[n, 1], query_boxes[k, 1]) + 1
+ *                 )
+ */
+        __pyx_t_32 = __pyx_v_k;
+        __pyx_t_33 = 3;
+        __pyx_t_10 = -1;
+        if (unlikely(__pyx_t_32 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+        if (__pyx_t_33 < 0) {
+          __pyx_t_33 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+          if (unlikely(__pyx_t_33 < 0)) __pyx_t_10 = 1;
+        } else if (unlikely(__pyx_t_33 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+        if (unlikely(__pyx_t_10 != -1)) {
+          __Pyx_RaiseBufferIndexError(__pyx_t_10);
+          __PYX_ERR(0, 177, __pyx_L1_error)
+        }
+        __pyx_t_30 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_32, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_33, __pyx_pybuffernd_query_boxes.diminfo[1].strides));
+        __pyx_t_34 = __pyx_v_n;
+        __pyx_t_35 = 3;
+        __pyx_t_10 = -1;
+        if (unlikely(__pyx_t_34 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+        if (__pyx_t_35 < 0) {
+          __pyx_t_35 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+          if (unlikely(__pyx_t_35 < 0)) __pyx_t_10 = 1;
+        } else if (unlikely(__pyx_t_35 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+        if (unlikely(__pyx_t_10 != -1)) {
+          __Pyx_RaiseBufferIndexError(__pyx_t_10);
+          __PYX_ERR(0, 177, __pyx_L1_error)
+        }
+        __pyx_t_25 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_34, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_35, __pyx_pybuffernd_boxes.diminfo[1].strides));
+        if (((__pyx_t_30 < __pyx_t_25) != 0)) {
+          __pyx_t_21 = __pyx_t_30;
+        } else {
+          __pyx_t_21 = __pyx_t_25;
+        }
+
+        /* "bbox.pyx":178
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -
+ *                     max(boxes[n, 1], query_boxes[k, 1]) + 1             # <<<<<<<<<<<<<<
+ *                 )
+ *                 if ih > 0:
+ */
+        __pyx_t_36 = __pyx_v_k;
+        __pyx_t_37 = 1;
+        __pyx_t_10 = -1;
+        if (unlikely(__pyx_t_36 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+        if (__pyx_t_37 < 0) {
+          __pyx_t_37 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+          if (unlikely(__pyx_t_37 < 0)) __pyx_t_10 = 1;
+        } else if (unlikely(__pyx_t_37 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+        if (unlikely(__pyx_t_10 != -1)) {
+          __Pyx_RaiseBufferIndexError(__pyx_t_10);
+          __PYX_ERR(0, 178, __pyx_L1_error)
+        }
+        __pyx_t_30 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_36, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_37, __pyx_pybuffernd_query_boxes.diminfo[1].strides));
+        __pyx_t_38 = __pyx_v_n;
+        __pyx_t_39 = 1;
+        __pyx_t_10 = -1;
+        if (unlikely(__pyx_t_38 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+        if (__pyx_t_39 < 0) {
+          __pyx_t_39 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+          if (unlikely(__pyx_t_39 < 0)) __pyx_t_10 = 1;
+        } else if (unlikely(__pyx_t_39 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+        if (unlikely(__pyx_t_10 != -1)) {
+          __Pyx_RaiseBufferIndexError(__pyx_t_10);
+          __PYX_ERR(0, 178, __pyx_L1_error)
+        }
+        __pyx_t_25 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_38, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_39, __pyx_pybuffernd_boxes.diminfo[1].strides));
+        if (((__pyx_t_30 > __pyx_t_25) != 0)) {
+          __pyx_t_24 = __pyx_t_30;
+        } else {
+          __pyx_t_24 = __pyx_t_25;
+        }
+
+        /* "bbox.pyx":177
+ *             if iw > 0:
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -             # <<<<<<<<<<<<<<
+ *                     max(boxes[n, 1], query_boxes[k, 1]) + 1
+ *                 )
+ */
+        __pyx_v_ih = ((__pyx_t_21 - __pyx_t_24) + 1.0);
+
+        /* "bbox.pyx":180
+ *                     max(boxes[n, 1], query_boxes[k, 1]) + 1
+ *                 )
+ *                 if ih > 0:             # <<<<<<<<<<<<<<
+ *                     if query_boxes[k, 4] == -1:
+ *                         ua = float((boxes[n, 2] - boxes[n, 0] + 1)
+ */
+        __pyx_t_31 = ((__pyx_v_ih > 0.0) != 0);
+        if (__pyx_t_31) {
+
+          /* "bbox.pyx":181
+ *                 )
+ *                 if ih > 0:
+ *                     if query_boxes[k, 4] == -1:             # <<<<<<<<<<<<<<
+ *                         ua = float((boxes[n, 2] - boxes[n, 0] + 1)
+ *                                   *(boxes[n, 3] - boxes[n, 1] + 1))
+ */
+          __pyx_t_40 = __pyx_v_k;
+          __pyx_t_41 = 4;
+          __pyx_t_10 = -1;
+          if (unlikely(__pyx_t_40 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+          if (__pyx_t_41 < 0) {
+            __pyx_t_41 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+            if (unlikely(__pyx_t_41 < 0)) __pyx_t_10 = 1;
+          } else if (unlikely(__pyx_t_41 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+          if (unlikely(__pyx_t_10 != -1)) {
+            __Pyx_RaiseBufferIndexError(__pyx_t_10);
+            __PYX_ERR(0, 181, __pyx_L1_error)
+          }
+          __pyx_t_31 = (((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_40, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_41, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) == -1.0) != 0);
+          if (__pyx_t_31) {
+
+            /* "bbox.pyx":182
+ *                 if ih > 0:
+ *                     if query_boxes[k, 4] == -1:
+ *                         ua = float((boxes[n, 2] - boxes[n, 0] + 1)             # <<<<<<<<<<<<<<
+ *                                   *(boxes[n, 3] - boxes[n, 1] + 1))
+ *                     else:
+ */
+            __pyx_t_42 = __pyx_v_n;
+            __pyx_t_43 = 2;
+            __pyx_t_10 = -1;
+            if (unlikely(__pyx_t_42 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+            if (__pyx_t_43 < 0) {
+              __pyx_t_43 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+              if (unlikely(__pyx_t_43 < 0)) __pyx_t_10 = 1;
+            } else if (unlikely(__pyx_t_43 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+            if (unlikely(__pyx_t_10 != -1)) {
+              __Pyx_RaiseBufferIndexError(__pyx_t_10);
+              __PYX_ERR(0, 182, __pyx_L1_error)
+            }
+            __pyx_t_44 = __pyx_v_n;
+            __pyx_t_45 = 0;
+            __pyx_t_10 = -1;
+            if (unlikely(__pyx_t_44 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+            if (__pyx_t_45 < 0) {
+              __pyx_t_45 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+              if (unlikely(__pyx_t_45 < 0)) __pyx_t_10 = 1;
+            } else if (unlikely(__pyx_t_45 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+            if (unlikely(__pyx_t_10 != -1)) {
+              __Pyx_RaiseBufferIndexError(__pyx_t_10);
+              __PYX_ERR(0, 182, __pyx_L1_error)
+            }
+
+            /* "bbox.pyx":183
+ *                     if query_boxes[k, 4] == -1:
+ *                         ua = float((boxes[n, 2] - boxes[n, 0] + 1)
+ *                                   *(boxes[n, 3] - boxes[n, 1] + 1))             # <<<<<<<<<<<<<<
+ *                     else:
+ *                         ua = float(
+ */
+            __pyx_t_46 = __pyx_v_n;
+            __pyx_t_47 = 3;
+            __pyx_t_10 = -1;
+            if (unlikely(__pyx_t_46 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+            if (__pyx_t_47 < 0) {
+              __pyx_t_47 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+              if (unlikely(__pyx_t_47 < 0)) __pyx_t_10 = 1;
+            } else if (unlikely(__pyx_t_47 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+            if (unlikely(__pyx_t_10 != -1)) {
+              __Pyx_RaiseBufferIndexError(__pyx_t_10);
+              __PYX_ERR(0, 183, __pyx_L1_error)
+            }
+            __pyx_t_48 = __pyx_v_n;
+            __pyx_t_49 = 1;
+            __pyx_t_10 = -1;
+            if (unlikely(__pyx_t_48 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+            if (__pyx_t_49 < 0) {
+              __pyx_t_49 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+              if (unlikely(__pyx_t_49 < 0)) __pyx_t_10 = 1;
+            } else if (unlikely(__pyx_t_49 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+            if (unlikely(__pyx_t_10 != -1)) {
+              __Pyx_RaiseBufferIndexError(__pyx_t_10);
+              __PYX_ERR(0, 183, __pyx_L1_error)
+            }
+
+            /* "bbox.pyx":182
+ *                 if ih > 0:
+ *                     if query_boxes[k, 4] == -1:
+ *                         ua = float((boxes[n, 2] - boxes[n, 0] + 1)             # <<<<<<<<<<<<<<
+ *                                   *(boxes[n, 3] - boxes[n, 1] + 1))
+ *                     else:
+ */
+            __pyx_v_ua = ((double)((((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_42, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_43, __pyx_pybuffernd_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_44, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_45, __pyx_pybuffernd_boxes.diminfo[1].strides))) + 1.0) * (((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_46, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_47, __pyx_pybuffernd_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_48, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_49, __pyx_pybuffernd_boxes.diminfo[1].strides))) + 1.0)));
+
+            /* "bbox.pyx":181
+ *                 )
+ *                 if ih > 0:
+ *                     if query_boxes[k, 4] == -1:             # <<<<<<<<<<<<<<
+ *                         ua = float((boxes[n, 2] - boxes[n, 0] + 1)
+ *                                   *(boxes[n, 3] - boxes[n, 1] + 1))
+ */
+            goto __pyx_L9;
+          }
+
+          /* "bbox.pyx":185
+ *                                   *(boxes[n, 3] - boxes[n, 1] + 1))
+ *                     else:
+ *                         ua = float(             # <<<<<<<<<<<<<<
+ *                             (boxes[n, 2] - boxes[n, 0] + 1) *
+ *                             (boxes[n, 3] - boxes[n, 1] + 1) +
+ */
+          /*else*/ {
+
+            /* "bbox.pyx":186
+ *                     else:
+ *                         ua = float(
+ *                             (boxes[n, 2] - boxes[n, 0] + 1) *             # <<<<<<<<<<<<<<
+ *                             (boxes[n, 3] - boxes[n, 1] + 1) +
+ *                             box_area - iw * ih
+ */
+            __pyx_t_50 = __pyx_v_n;
+            __pyx_t_51 = 2;
+            __pyx_t_10 = -1;
+            if (unlikely(__pyx_t_50 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+            if (__pyx_t_51 < 0) {
+              __pyx_t_51 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+              if (unlikely(__pyx_t_51 < 0)) __pyx_t_10 = 1;
+            } else if (unlikely(__pyx_t_51 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+            if (unlikely(__pyx_t_10 != -1)) {
+              __Pyx_RaiseBufferIndexError(__pyx_t_10);
+              __PYX_ERR(0, 186, __pyx_L1_error)
+            }
+            __pyx_t_52 = __pyx_v_n;
+            __pyx_t_53 = 0;
+            __pyx_t_10 = -1;
+            if (unlikely(__pyx_t_52 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+            if (__pyx_t_53 < 0) {
+              __pyx_t_53 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+              if (unlikely(__pyx_t_53 < 0)) __pyx_t_10 = 1;
+            } else if (unlikely(__pyx_t_53 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+            if (unlikely(__pyx_t_10 != -1)) {
+              __Pyx_RaiseBufferIndexError(__pyx_t_10);
+              __PYX_ERR(0, 186, __pyx_L1_error)
+            }
+
+            /* "bbox.pyx":187
+ *                         ua = float(
+ *                             (boxes[n, 2] - boxes[n, 0] + 1) *
+ *                             (boxes[n, 3] - boxes[n, 1] + 1) +             # <<<<<<<<<<<<<<
+ *                             box_area - iw * ih
+ *                         )
+ */
+            __pyx_t_54 = __pyx_v_n;
+            __pyx_t_55 = 3;
+            __pyx_t_10 = -1;
+            if (unlikely(__pyx_t_54 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+            if (__pyx_t_55 < 0) {
+              __pyx_t_55 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+              if (unlikely(__pyx_t_55 < 0)) __pyx_t_10 = 1;
+            } else if (unlikely(__pyx_t_55 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+            if (unlikely(__pyx_t_10 != -1)) {
+              __Pyx_RaiseBufferIndexError(__pyx_t_10);
+              __PYX_ERR(0, 187, __pyx_L1_error)
+            }
+            __pyx_t_56 = __pyx_v_n;
+            __pyx_t_57 = 1;
+            __pyx_t_10 = -1;
+            if (unlikely(__pyx_t_56 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0;
+            if (__pyx_t_57 < 0) {
+              __pyx_t_57 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+              if (unlikely(__pyx_t_57 < 0)) __pyx_t_10 = 1;
+            } else if (unlikely(__pyx_t_57 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1;
+            if (unlikely(__pyx_t_10 != -1)) {
+              __Pyx_RaiseBufferIndexError(__pyx_t_10);
+              __PYX_ERR(0, 187, __pyx_L1_error)
+            }
+
+            /* "bbox.pyx":185
+ *                                   *(boxes[n, 3] - boxes[n, 1] + 1))
+ *                     else:
+ *                         ua = float(             # <<<<<<<<<<<<<<
+ *                             (boxes[n, 2] - boxes[n, 0] + 1) *
+ *                             (boxes[n, 3] - boxes[n, 1] + 1) +
+ */
+            __pyx_v_ua = ((double)((((((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_50, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_51, __pyx_pybuffernd_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_52, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_53, __pyx_pybuffernd_boxes.diminfo[1].strides))) + 1.0) * (((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_54, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_55, __pyx_pybuffernd_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_56, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_57, __pyx_pybuffernd_boxes.diminfo[1].strides))) + 1.0)) + __pyx_v_box_area) - (__pyx_v_iw * __pyx_v_ih)));
+          }
+          __pyx_L9:;
+
+          /* "bbox.pyx":190
+ *                             box_area - iw * ih
+ *                         )
+ *                     overlaps[n, k] = iw * ih / ua             # <<<<<<<<<<<<<<
+ *     return overlaps
+ * 
+ */
+          __pyx_t_24 = (__pyx_v_iw * __pyx_v_ih);
+          if (unlikely(__pyx_v_ua == 0)) {
+            PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+            __PYX_ERR(0, 190, __pyx_L1_error)
+          }
+          __pyx_t_58 = __pyx_v_n;
+          __pyx_t_59 = __pyx_v_k;
+          __pyx_t_10 = -1;
+          if (unlikely(__pyx_t_58 >= (size_t)__pyx_pybuffernd_overlaps.diminfo[0].shape)) __pyx_t_10 = 0;
+          if (unlikely(__pyx_t_59 >= (size_t)__pyx_pybuffernd_overlaps.diminfo[1].shape)) __pyx_t_10 = 1;
+          if (unlikely(__pyx_t_10 != -1)) {
+            __Pyx_RaiseBufferIndexError(__pyx_t_10);
+            __PYX_ERR(0, 190, __pyx_L1_error)
+          }
+          *__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.buf, __pyx_t_58, __pyx_pybuffernd_overlaps.diminfo[0].strides, __pyx_t_59, __pyx_pybuffernd_overlaps.diminfo[1].strides) = (__pyx_t_24 / __pyx_v_ua);
+
+          /* "bbox.pyx":180
+ *                     max(boxes[n, 1], query_boxes[k, 1]) + 1
+ *                 )
+ *                 if ih > 0:             # <<<<<<<<<<<<<<
+ *                     if query_boxes[k, 4] == -1:
+ *                         ua = float((boxes[n, 2] - boxes[n, 0] + 1)
+ */
+        }
+
+        /* "bbox.pyx":175
+ *                 max(boxes[n, 0], query_boxes[k, 0]) + 1
+ *             )
+ *             if iw > 0:             # <<<<<<<<<<<<<<
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -
+ */
+      }
+    }
+  }
+
+  /* "bbox.pyx":191
+ *                         )
+ *                     overlaps[n, k] = iw * ih / ua
+ *     return overlaps             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_overlaps));
+  __pyx_r = ((PyObject *)__pyx_v_overlaps);
+  goto __pyx_L0;
+
+  /* "bbox.pyx":147
+ * 
+ * 
+ * def bbox_overlaps_ignore(             # <<<<<<<<<<<<<<
+ *         np.ndarray[DTYPE_t, ndim=2] boxes,
+ *         np.ndarray[DTYPE_t, ndim=2] query_boxes):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_overlaps.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("cython_bbox.bbox_overlaps_ignore", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_overlaps.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_overlaps);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "bbox.pyx":194
+ * 
+ * 
+ * def get_assignment_overlaps(             # <<<<<<<<<<<<<<
+ *         np.ndarray[DTYPE_t, ndim=2] boxes,
+ *         np.ndarray[DTYPE_t, ndim=2] query_boxes,
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11cython_bbox_9get_assignment_overlaps(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_11cython_bbox_8get_assignment_overlaps[] = " Used for proposal_target_layer_ignore\n    Parameters\n    ----------\n    boxes: (N, 4) ndarray of float\n    query_boxes: (K, 4) ndarray of float\n    Returns\n    -------\n    overlaps: (N, K) ndarray of overlap between boxes and query_boxes\n    ";
+static PyMethodDef __pyx_mdef_11cython_bbox_9get_assignment_overlaps = {"get_assignment_overlaps", (PyCFunction)__pyx_pw_11cython_bbox_9get_assignment_overlaps, METH_VARARGS|METH_KEYWORDS, __pyx_doc_11cython_bbox_8get_assignment_overlaps};
+static PyObject *__pyx_pw_11cython_bbox_9get_assignment_overlaps(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyArrayObject *__pyx_v_boxes = 0;
+  PyArrayObject *__pyx_v_query_boxes = 0;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_v_FG_THRESH;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_assignment_overlaps (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_boxes,&__pyx_n_s_query_boxes,&__pyx_n_s_FG_THRESH,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_boxes)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_query_boxes)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("get_assignment_overlaps", 1, 3, 3, 1); __PYX_ERR(0, 194, __pyx_L3_error)
+        }
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_FG_THRESH)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("get_assignment_overlaps", 1, 3, 3, 2); __PYX_ERR(0, 194, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_assignment_overlaps") < 0)) __PYX_ERR(0, 194, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    }
+    __pyx_v_boxes = ((PyArrayObject *)values[0]);
+    __pyx_v_query_boxes = ((PyArrayObject *)values[1]);
+    __pyx_v_FG_THRESH = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_FG_THRESH == ((npy_double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 197, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("get_assignment_overlaps", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 194, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("cython_bbox.get_assignment_overlaps", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_boxes), __pyx_ptype_5numpy_ndarray, 1, "boxes", 0))) __PYX_ERR(0, 195, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_query_boxes), __pyx_ptype_5numpy_ndarray, 1, "query_boxes", 0))) __PYX_ERR(0, 196, __pyx_L1_error)
+  __pyx_r = __pyx_pf_11cython_bbox_8get_assignment_overlaps(__pyx_self, __pyx_v_boxes, __pyx_v_query_boxes, __pyx_v_FG_THRESH);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_11cython_bbox_8get_assignment_overlaps(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_boxes, PyArrayObject *__pyx_v_query_boxes, __pyx_t_11cython_bbox_DTYPE_t __pyx_v_FG_THRESH) {
+  unsigned int __pyx_v_N;
+  unsigned int __pyx_v_K;
+  PyArrayObject *__pyx_v_gt_assignment = 0;
+  PyArrayObject *__pyx_v_max_overlaps = 0;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_v_iw;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_v_ih;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_v_box_area;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_v_ua;
+  unsigned int __pyx_v_k;
+  unsigned int __pyx_v_n;
+  PyObject *__pyx_v_overlap = NULL;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_boxes;
+  __Pyx_Buffer __pyx_pybuffer_boxes;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_gt_assignment;
+  __Pyx_Buffer __pyx_pybuffer_gt_assignment;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_max_overlaps;
+  __Pyx_Buffer __pyx_pybuffer_max_overlaps;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_query_boxes;
+  __Pyx_Buffer __pyx_pybuffer_query_boxes;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyArrayObject *__pyx_t_6 = NULL;
+  PyArrayObject *__pyx_t_7 = NULL;
+  unsigned int __pyx_t_8;
+  unsigned int __pyx_t_9;
+  size_t __pyx_t_10;
+  Py_ssize_t __pyx_t_11;
+  int __pyx_t_12;
+  size_t __pyx_t_13;
+  Py_ssize_t __pyx_t_14;
+  size_t __pyx_t_15;
+  Py_ssize_t __pyx_t_16;
+  size_t __pyx_t_17;
+  Py_ssize_t __pyx_t_18;
+  unsigned int __pyx_t_19;
+  unsigned int __pyx_t_20;
+  size_t __pyx_t_21;
+  Py_ssize_t __pyx_t_22;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_t_23;
+  size_t __pyx_t_24;
+  Py_ssize_t __pyx_t_25;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_t_26;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_t_27;
+  size_t __pyx_t_28;
+  Py_ssize_t __pyx_t_29;
+  size_t __pyx_t_30;
+  Py_ssize_t __pyx_t_31;
+  __pyx_t_11cython_bbox_DTYPE_t __pyx_t_32;
+  int __pyx_t_33;
+  size_t __pyx_t_34;
+  Py_ssize_t __pyx_t_35;
+  size_t __pyx_t_36;
+  Py_ssize_t __pyx_t_37;
+  size_t __pyx_t_38;
+  Py_ssize_t __pyx_t_39;
+  size_t __pyx_t_40;
+  Py_ssize_t __pyx_t_41;
+  size_t __pyx_t_42;
+  Py_ssize_t __pyx_t_43;
+  size_t __pyx_t_44;
+  Py_ssize_t __pyx_t_45;
+  size_t __pyx_t_46;
+  Py_ssize_t __pyx_t_47;
+  size_t __pyx_t_48;
+  Py_ssize_t __pyx_t_49;
+  size_t __pyx_t_50;
+  Py_ssize_t __pyx_t_51;
+  size_t __pyx_t_52;
+  size_t __pyx_t_53;
+  Py_ssize_t __pyx_t_54;
+  Py_ssize_t __pyx_t_55;
+  int __pyx_t_56;
+  size_t __pyx_t_57;
+  size_t __pyx_t_58;
+  size_t __pyx_t_59;
+  size_t __pyx_t_60;
+  Py_ssize_t __pyx_t_61;
+  size_t __pyx_t_62;
+  Py_ssize_t __pyx_t_63;
+  size_t __pyx_t_64;
+  Py_ssize_t __pyx_t_65;
+  size_t __pyx_t_66;
+  Py_ssize_t __pyx_t_67;
+  size_t __pyx_t_68;
+  size_t __pyx_t_69;
+  size_t __pyx_t_70;
+  __Pyx_RefNannySetupContext("get_assignment_overlaps", 0);
+  __pyx_pybuffer_gt_assignment.pybuffer.buf = NULL;
+  __pyx_pybuffer_gt_assignment.refcount = 0;
+  __pyx_pybuffernd_gt_assignment.data = NULL;
+  __pyx_pybuffernd_gt_assignment.rcbuffer = &__pyx_pybuffer_gt_assignment;
+  __pyx_pybuffer_max_overlaps.pybuffer.buf = NULL;
+  __pyx_pybuffer_max_overlaps.refcount = 0;
+  __pyx_pybuffernd_max_overlaps.data = NULL;
+  __pyx_pybuffernd_max_overlaps.rcbuffer = &__pyx_pybuffer_max_overlaps;
+  __pyx_pybuffer_boxes.pybuffer.buf = NULL;
+  __pyx_pybuffer_boxes.refcount = 0;
+  __pyx_pybuffernd_boxes.data = NULL;
+  __pyx_pybuffernd_boxes.rcbuffer = &__pyx_pybuffer_boxes;
+  __pyx_pybuffer_query_boxes.pybuffer.buf = NULL;
+  __pyx_pybuffer_query_boxes.refcount = 0;
+  __pyx_pybuffernd_query_boxes.data = NULL;
+  __pyx_pybuffernd_query_boxes.rcbuffer = &__pyx_pybuffer_query_boxes;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer, (PyObject*)__pyx_v_boxes, &__Pyx_TypeInfo_nn___pyx_t_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 194, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_boxes.diminfo[0].strides = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_boxes.diminfo[0].shape = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_boxes.diminfo[1].strides = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_boxes.diminfo[1].shape = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.shape[1];
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer, (PyObject*)__pyx_v_query_boxes, &__Pyx_TypeInfo_nn___pyx_t_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 194, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_query_boxes.diminfo[0].strides = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_query_boxes.diminfo[0].shape = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_query_boxes.diminfo[1].strides = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_query_boxes.diminfo[1].shape = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.shape[1];
+
+  /* "bbox.pyx":207
+ *     overlaps: (N, K) ndarray of overlap between boxes and query_boxes
+ *     """
+ *     cdef unsigned int N = boxes.shape[0]             # <<<<<<<<<<<<<<
+ *     cdef unsigned int K = query_boxes.shape[0]
+ *     cdef np.ndarray[long, ndim=1] gt_assignment = np.zeros((N,), dtype=np.int)
+ */
+  __pyx_v_N = (__pyx_v_boxes->dimensions[0]);
+
+  /* "bbox.pyx":208
+ *     """
+ *     cdef unsigned int N = boxes.shape[0]
+ *     cdef unsigned int K = query_boxes.shape[0]             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[long, ndim=1] gt_assignment = np.zeros((N,), dtype=np.int)
+ *     cdef np.ndarray[DTYPE_t, ndim=1] max_overlaps = np.zeros((N,), dtype=DTYPE)
+ */
+  __pyx_v_K = (__pyx_v_query_boxes->dimensions[0]);
+
+  /* "bbox.pyx":209
+ *     cdef unsigned int N = boxes.shape[0]
+ *     cdef unsigned int K = query_boxes.shape[0]
+ *     cdef np.ndarray[long, ndim=1] gt_assignment = np.zeros((N,), dtype=np.int)             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[DTYPE_t, ndim=1] max_overlaps = np.zeros((N,), dtype=DTYPE)
+ *     cdef DTYPE_t iw, ih, box_area
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_N); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_int); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 209, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 209, __pyx_L1_error)
+  __pyx_t_6 = ((PyArrayObject *)__pyx_t_5);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_gt_assignment.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_long, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_gt_assignment = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_gt_assignment.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 209, __pyx_L1_error)
+    } else {__pyx_pybuffernd_gt_assignment.diminfo[0].strides = __pyx_pybuffernd_gt_assignment.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_gt_assignment.diminfo[0].shape = __pyx_pybuffernd_gt_assignment.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_6 = 0;
+  __pyx_v_gt_assignment = ((PyArrayObject *)__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "bbox.pyx":210
+ *     cdef unsigned int K = query_boxes.shape[0]
+ *     cdef np.ndarray[long, ndim=1] gt_assignment = np.zeros((N,), dtype=np.int)
+ *     cdef np.ndarray[DTYPE_t, ndim=1] max_overlaps = np.zeros((N,), dtype=DTYPE)             # <<<<<<<<<<<<<<
+ *     cdef DTYPE_t iw, ih, box_area
+ *     cdef DTYPE_t ua
+ */
+  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_N); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_5);
+  __pyx_t_5 = 0;
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_2) < 0) __PYX_ERR(0, 210, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 210, __pyx_L1_error)
+  __pyx_t_7 = ((PyArrayObject *)__pyx_t_2);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_max_overlaps.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_nn___pyx_t_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_max_overlaps = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_max_overlaps.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 210, __pyx_L1_error)
+    } else {__pyx_pybuffernd_max_overlaps.diminfo[0].strides = __pyx_pybuffernd_max_overlaps.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_max_overlaps.diminfo[0].shape = __pyx_pybuffernd_max_overlaps.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_7 = 0;
+  __pyx_v_max_overlaps = ((PyArrayObject *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "bbox.pyx":214
+ *     cdef DTYPE_t ua
+ *     cdef unsigned int k, n
+ *     for k in range(K):             # <<<<<<<<<<<<<<
+ *         box_area = (
+ *             (query_boxes[k, 2] - query_boxes[k, 0] + 1) *
+ */
+  __pyx_t_8 = __pyx_v_K;
+  for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_8; __pyx_t_9+=1) {
+    __pyx_v_k = __pyx_t_9;
+
+    /* "bbox.pyx":216
+ *     for k in range(K):
+ *         box_area = (
+ *             (query_boxes[k, 2] - query_boxes[k, 0] + 1) *             # <<<<<<<<<<<<<<
+ *             (query_boxes[k, 3] - query_boxes[k, 1] + 1)
+ *         )
+ */
+    __pyx_t_10 = __pyx_v_k;
+    __pyx_t_11 = 2;
+    __pyx_t_12 = -1;
+    if (unlikely(__pyx_t_10 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_12 = 0;
+    if (__pyx_t_11 < 0) {
+      __pyx_t_11 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+      if (unlikely(__pyx_t_11 < 0)) __pyx_t_12 = 1;
+    } else if (unlikely(__pyx_t_11 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_12 = 1;
+    if (unlikely(__pyx_t_12 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_12);
+      __PYX_ERR(0, 216, __pyx_L1_error)
+    }
+    __pyx_t_13 = __pyx_v_k;
+    __pyx_t_14 = 0;
+    __pyx_t_12 = -1;
+    if (unlikely(__pyx_t_13 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_12 = 0;
+    if (__pyx_t_14 < 0) {
+      __pyx_t_14 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+      if (unlikely(__pyx_t_14 < 0)) __pyx_t_12 = 1;
+    } else if (unlikely(__pyx_t_14 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_12 = 1;
+    if (unlikely(__pyx_t_12 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_12);
+      __PYX_ERR(0, 216, __pyx_L1_error)
+    }
+
+    /* "bbox.pyx":217
+ *         box_area = (
+ *             (query_boxes[k, 2] - query_boxes[k, 0] + 1) *
+ *             (query_boxes[k, 3] - query_boxes[k, 1] + 1)             # <<<<<<<<<<<<<<
+ *         )
+ *         for n in range(N):
+ */
+    __pyx_t_15 = __pyx_v_k;
+    __pyx_t_16 = 3;
+    __pyx_t_12 = -1;
+    if (unlikely(__pyx_t_15 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_12 = 0;
+    if (__pyx_t_16 < 0) {
+      __pyx_t_16 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+      if (unlikely(__pyx_t_16 < 0)) __pyx_t_12 = 1;
+    } else if (unlikely(__pyx_t_16 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_12 = 1;
+    if (unlikely(__pyx_t_12 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_12);
+      __PYX_ERR(0, 217, __pyx_L1_error)
+    }
+    __pyx_t_17 = __pyx_v_k;
+    __pyx_t_18 = 1;
+    __pyx_t_12 = -1;
+    if (unlikely(__pyx_t_17 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_12 = 0;
+    if (__pyx_t_18 < 0) {
+      __pyx_t_18 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+      if (unlikely(__pyx_t_18 < 0)) __pyx_t_12 = 1;
+    } else if (unlikely(__pyx_t_18 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_12 = 1;
+    if (unlikely(__pyx_t_12 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_12);
+      __PYX_ERR(0, 217, __pyx_L1_error)
+    }
+
+    /* "bbox.pyx":216
+ *     for k in range(K):
+ *         box_area = (
+ *             (query_boxes[k, 2] - query_boxes[k, 0] + 1) *             # <<<<<<<<<<<<<<
+ *             (query_boxes[k, 3] - query_boxes[k, 1] + 1)
+ *         )
+ */
+    __pyx_v_box_area = ((((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_10, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_11, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_13, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_14, __pyx_pybuffernd_query_boxes.diminfo[1].strides))) + 1.0) * (((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_16, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_18, __pyx_pybuffernd_query_boxes.diminfo[1].strides))) + 1.0));
+
+    /* "bbox.pyx":219
+ *             (query_boxes[k, 3] - query_boxes[k, 1] + 1)
+ *         )
+ *         for n in range(N):             # <<<<<<<<<<<<<<
+ *             iw = (
+ *                 min(boxes[n, 2], query_boxes[k, 2]) -
+ */
+    __pyx_t_19 = __pyx_v_N;
+    for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) {
+      __pyx_v_n = __pyx_t_20;
+
+      /* "bbox.pyx":221
+ *         for n in range(N):
+ *             iw = (
+ *                 min(boxes[n, 2], query_boxes[k, 2]) -             # <<<<<<<<<<<<<<
+ *                 max(boxes[n, 0], query_boxes[k, 0]) + 1
+ *             )
+ */
+      __pyx_t_21 = __pyx_v_k;
+      __pyx_t_22 = 2;
+      __pyx_t_12 = -1;
+      if (unlikely(__pyx_t_21 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_12 = 0;
+      if (__pyx_t_22 < 0) {
+        __pyx_t_22 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+        if (unlikely(__pyx_t_22 < 0)) __pyx_t_12 = 1;
+      } else if (unlikely(__pyx_t_22 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_12 = 1;
+      if (unlikely(__pyx_t_12 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_12);
+        __PYX_ERR(0, 221, __pyx_L1_error)
+      }
+      __pyx_t_23 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_21, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_22, __pyx_pybuffernd_query_boxes.diminfo[1].strides));
+      __pyx_t_24 = __pyx_v_n;
+      __pyx_t_25 = 2;
+      __pyx_t_12 = -1;
+      if (unlikely(__pyx_t_24 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_12 = 0;
+      if (__pyx_t_25 < 0) {
+        __pyx_t_25 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+        if (unlikely(__pyx_t_25 < 0)) __pyx_t_12 = 1;
+      } else if (unlikely(__pyx_t_25 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_12 = 1;
+      if (unlikely(__pyx_t_12 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_12);
+        __PYX_ERR(0, 221, __pyx_L1_error)
+      }
+      __pyx_t_26 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_24, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_25, __pyx_pybuffernd_boxes.diminfo[1].strides));
+      if (((__pyx_t_23 < __pyx_t_26) != 0)) {
+        __pyx_t_27 = __pyx_t_23;
+      } else {
+        __pyx_t_27 = __pyx_t_26;
+      }
+
+      /* "bbox.pyx":222
+ *             iw = (
+ *                 min(boxes[n, 2], query_boxes[k, 2]) -
+ *                 max(boxes[n, 0], query_boxes[k, 0]) + 1             # <<<<<<<<<<<<<<
+ *             )
+ *             if iw > 0:
+ */
+      __pyx_t_28 = __pyx_v_k;
+      __pyx_t_29 = 0;
+      __pyx_t_12 = -1;
+      if (unlikely(__pyx_t_28 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_12 = 0;
+      if (__pyx_t_29 < 0) {
+        __pyx_t_29 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+        if (unlikely(__pyx_t_29 < 0)) __pyx_t_12 = 1;
+      } else if (unlikely(__pyx_t_29 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_12 = 1;
+      if (unlikely(__pyx_t_12 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_12);
+        __PYX_ERR(0, 222, __pyx_L1_error)
+      }
+      __pyx_t_23 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_28, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_29, __pyx_pybuffernd_query_boxes.diminfo[1].strides));
+      __pyx_t_30 = __pyx_v_n;
+      __pyx_t_31 = 0;
+      __pyx_t_12 = -1;
+      if (unlikely(__pyx_t_30 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_12 = 0;
+      if (__pyx_t_31 < 0) {
+        __pyx_t_31 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+        if (unlikely(__pyx_t_31 < 0)) __pyx_t_12 = 1;
+      } else if (unlikely(__pyx_t_31 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_12 = 1;
+      if (unlikely(__pyx_t_12 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_12);
+        __PYX_ERR(0, 222, __pyx_L1_error)
+      }
+      __pyx_t_26 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_30, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_31, __pyx_pybuffernd_boxes.diminfo[1].strides));
+      if (((__pyx_t_23 > __pyx_t_26) != 0)) {
+        __pyx_t_32 = __pyx_t_23;
+      } else {
+        __pyx_t_32 = __pyx_t_26;
+      }
+
+      /* "bbox.pyx":221
+ *         for n in range(N):
+ *             iw = (
+ *                 min(boxes[n, 2], query_boxes[k, 2]) -             # <<<<<<<<<<<<<<
+ *                 max(boxes[n, 0], query_boxes[k, 0]) + 1
+ *             )
+ */
+      __pyx_v_iw = ((__pyx_t_27 - __pyx_t_32) + 1.0);
+
+      /* "bbox.pyx":224
+ *                 max(boxes[n, 0], query_boxes[k, 0]) + 1
+ *             )
+ *             if iw > 0:             # <<<<<<<<<<<<<<
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -
+ */
+      __pyx_t_33 = ((__pyx_v_iw > 0.0) != 0);
+      if (__pyx_t_33) {
+
+        /* "bbox.pyx":226
+ *             if iw > 0:
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -             # <<<<<<<<<<<<<<
+ *                     max(boxes[n, 1], query_boxes[k, 1]) + 1
+ *                 )
+ */
+        __pyx_t_34 = __pyx_v_k;
+        __pyx_t_35 = 3;
+        __pyx_t_12 = -1;
+        if (unlikely(__pyx_t_34 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_12 = 0;
+        if (__pyx_t_35 < 0) {
+          __pyx_t_35 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+          if (unlikely(__pyx_t_35 < 0)) __pyx_t_12 = 1;
+        } else if (unlikely(__pyx_t_35 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_12 = 1;
+        if (unlikely(__pyx_t_12 != -1)) {
+          __Pyx_RaiseBufferIndexError(__pyx_t_12);
+          __PYX_ERR(0, 226, __pyx_L1_error)
+        }
+        __pyx_t_32 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_34, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_35, __pyx_pybuffernd_query_boxes.diminfo[1].strides));
+        __pyx_t_36 = __pyx_v_n;
+        __pyx_t_37 = 3;
+        __pyx_t_12 = -1;
+        if (unlikely(__pyx_t_36 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_12 = 0;
+        if (__pyx_t_37 < 0) {
+          __pyx_t_37 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+          if (unlikely(__pyx_t_37 < 0)) __pyx_t_12 = 1;
+        } else if (unlikely(__pyx_t_37 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_12 = 1;
+        if (unlikely(__pyx_t_12 != -1)) {
+          __Pyx_RaiseBufferIndexError(__pyx_t_12);
+          __PYX_ERR(0, 226, __pyx_L1_error)
+        }
+        __pyx_t_27 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_36, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_37, __pyx_pybuffernd_boxes.diminfo[1].strides));
+        if (((__pyx_t_32 < __pyx_t_27) != 0)) {
+          __pyx_t_23 = __pyx_t_32;
+        } else {
+          __pyx_t_23 = __pyx_t_27;
+        }
+
+        /* "bbox.pyx":227
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -
+ *                     max(boxes[n, 1], query_boxes[k, 1]) + 1             # <<<<<<<<<<<<<<
+ *                 )
+ *                 if ih > 0:
+ */
+        __pyx_t_38 = __pyx_v_k;
+        __pyx_t_39 = 1;
+        __pyx_t_12 = -1;
+        if (unlikely(__pyx_t_38 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_12 = 0;
+        if (__pyx_t_39 < 0) {
+          __pyx_t_39 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+          if (unlikely(__pyx_t_39 < 0)) __pyx_t_12 = 1;
+        } else if (unlikely(__pyx_t_39 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_12 = 1;
+        if (unlikely(__pyx_t_12 != -1)) {
+          __Pyx_RaiseBufferIndexError(__pyx_t_12);
+          __PYX_ERR(0, 227, __pyx_L1_error)
+        }
+        __pyx_t_32 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_38, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_39, __pyx_pybuffernd_query_boxes.diminfo[1].strides));
+        __pyx_t_40 = __pyx_v_n;
+        __pyx_t_41 = 1;
+        __pyx_t_12 = -1;
+        if (unlikely(__pyx_t_40 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_12 = 0;
+        if (__pyx_t_41 < 0) {
+          __pyx_t_41 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+          if (unlikely(__pyx_t_41 < 0)) __pyx_t_12 = 1;
+        } else if (unlikely(__pyx_t_41 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_12 = 1;
+        if (unlikely(__pyx_t_12 != -1)) {
+          __Pyx_RaiseBufferIndexError(__pyx_t_12);
+          __PYX_ERR(0, 227, __pyx_L1_error)
+        }
+        __pyx_t_27 = (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_40, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_41, __pyx_pybuffernd_boxes.diminfo[1].strides));
+        if (((__pyx_t_32 > __pyx_t_27) != 0)) {
+          __pyx_t_26 = __pyx_t_32;
+        } else {
+          __pyx_t_26 = __pyx_t_27;
+        }
+
+        /* "bbox.pyx":226
+ *             if iw > 0:
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -             # <<<<<<<<<<<<<<
+ *                     max(boxes[n, 1], query_boxes[k, 1]) + 1
+ *                 )
+ */
+        __pyx_v_ih = ((__pyx_t_23 - __pyx_t_26) + 1.0);
+
+        /* "bbox.pyx":229
+ *                     max(boxes[n, 1], query_boxes[k, 1]) + 1
+ *                 )
+ *                 if ih > 0:             # <<<<<<<<<<<<<<
+ *                     if query_boxes[k, 4] == -1:
+ *                         ua = float((boxes[n, 2] - boxes[n, 0] + 1)
+ */
+        __pyx_t_33 = ((__pyx_v_ih > 0.0) != 0);
+        if (__pyx_t_33) {
+
+          /* "bbox.pyx":230
+ *                 )
+ *                 if ih > 0:
+ *                     if query_boxes[k, 4] == -1:             # <<<<<<<<<<<<<<
+ *                         ua = float((boxes[n, 2] - boxes[n, 0] + 1)
+ *                                   *(boxes[n, 3] - boxes[n, 1] + 1))
+ */
+          __pyx_t_42 = __pyx_v_k;
+          __pyx_t_43 = 4;
+          __pyx_t_12 = -1;
+          if (unlikely(__pyx_t_42 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_12 = 0;
+          if (__pyx_t_43 < 0) {
+            __pyx_t_43 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+            if (unlikely(__pyx_t_43 < 0)) __pyx_t_12 = 1;
+          } else if (unlikely(__pyx_t_43 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_12 = 1;
+          if (unlikely(__pyx_t_12 != -1)) {
+            __Pyx_RaiseBufferIndexError(__pyx_t_12);
+            __PYX_ERR(0, 230, __pyx_L1_error)
+          }
+          __pyx_t_33 = (((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_42, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_43, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) == -1.0) != 0);
+          if (__pyx_t_33) {
+
+            /* "bbox.pyx":231
+ *                 if ih > 0:
+ *                     if query_boxes[k, 4] == -1:
+ *                         ua = float((boxes[n, 2] - boxes[n, 0] + 1)             # <<<<<<<<<<<<<<
+ *                                   *(boxes[n, 3] - boxes[n, 1] + 1))
+ *                         overlap = iw * ih / ua
+ */
+            __pyx_t_44 = __pyx_v_n;
+            __pyx_t_45 = 2;
+            __pyx_t_12 = -1;
+            if (unlikely(__pyx_t_44 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_12 = 0;
+            if (__pyx_t_45 < 0) {
+              __pyx_t_45 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+              if (unlikely(__pyx_t_45 < 0)) __pyx_t_12 = 1;
+            } else if (unlikely(__pyx_t_45 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_12 = 1;
+            if (unlikely(__pyx_t_12 != -1)) {
+              __Pyx_RaiseBufferIndexError(__pyx_t_12);
+              __PYX_ERR(0, 231, __pyx_L1_error)
+            }
+            __pyx_t_46 = __pyx_v_n;
+            __pyx_t_47 = 0;
+            __pyx_t_12 = -1;
+            if (unlikely(__pyx_t_46 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_12 = 0;
+            if (__pyx_t_47 < 0) {
+              __pyx_t_47 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+              if (unlikely(__pyx_t_47 < 0)) __pyx_t_12 = 1;
+            } else if (unlikely(__pyx_t_47 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_12 = 1;
+            if (unlikely(__pyx_t_12 != -1)) {
+              __Pyx_RaiseBufferIndexError(__pyx_t_12);
+              __PYX_ERR(0, 231, __pyx_L1_error)
+            }
+
+            /* "bbox.pyx":232
+ *                     if query_boxes[k, 4] == -1:
+ *                         ua = float((boxes[n, 2] - boxes[n, 0] + 1)
+ *                                   *(boxes[n, 3] - boxes[n, 1] + 1))             # <<<<<<<<<<<<<<
+ *                         overlap = iw * ih / ua
+ *                         if overlap > max_overlaps[n]:
+ */
+            __pyx_t_48 = __pyx_v_n;
+            __pyx_t_49 = 3;
+            __pyx_t_12 = -1;
+            if (unlikely(__pyx_t_48 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_12 = 0;
+            if (__pyx_t_49 < 0) {
+              __pyx_t_49 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+              if (unlikely(__pyx_t_49 < 0)) __pyx_t_12 = 1;
+            } else if (unlikely(__pyx_t_49 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_12 = 1;
+            if (unlikely(__pyx_t_12 != -1)) {
+              __Pyx_RaiseBufferIndexError(__pyx_t_12);
+              __PYX_ERR(0, 232, __pyx_L1_error)
+            }
+            __pyx_t_50 = __pyx_v_n;
+            __pyx_t_51 = 1;
+            __pyx_t_12 = -1;
+            if (unlikely(__pyx_t_50 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_12 = 0;
+            if (__pyx_t_51 < 0) {
+              __pyx_t_51 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+              if (unlikely(__pyx_t_51 < 0)) __pyx_t_12 = 1;
+            } else if (unlikely(__pyx_t_51 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_12 = 1;
+            if (unlikely(__pyx_t_12 != -1)) {
+              __Pyx_RaiseBufferIndexError(__pyx_t_12);
+              __PYX_ERR(0, 232, __pyx_L1_error)
+            }
+
+            /* "bbox.pyx":231
+ *                 if ih > 0:
+ *                     if query_boxes[k, 4] == -1:
+ *                         ua = float((boxes[n, 2] - boxes[n, 0] + 1)             # <<<<<<<<<<<<<<
+ *                                   *(boxes[n, 3] - boxes[n, 1] + 1))
+ *                         overlap = iw * ih / ua
+ */
+            __pyx_v_ua = ((double)((((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_44, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_45, __pyx_pybuffernd_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_46, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_47, __pyx_pybuffernd_boxes.diminfo[1].strides))) + 1.0) * (((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_48, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_49, __pyx_pybuffernd_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_50, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_51, __pyx_pybuffernd_boxes.diminfo[1].strides))) + 1.0)));
+
+            /* "bbox.pyx":233
+ *                         ua = float((boxes[n, 2] - boxes[n, 0] + 1)
+ *                                   *(boxes[n, 3] - boxes[n, 1] + 1))
+ *                         overlap = iw * ih / ua             # <<<<<<<<<<<<<<
+ *                         if overlap > max_overlaps[n]:
+ *                             if query_boxes[gt_assignment[n], 4] == -1 or max_overlaps[n] < FG_THRESH:
+ */
+            __pyx_t_26 = (__pyx_v_iw * __pyx_v_ih);
+            if (unlikely(__pyx_v_ua == 0)) {
+              PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+              __PYX_ERR(0, 233, __pyx_L1_error)
+            }
+            __pyx_t_2 = PyFloat_FromDouble((__pyx_t_26 / __pyx_v_ua)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 233, __pyx_L1_error)
+            __Pyx_GOTREF(__pyx_t_2);
+            __Pyx_XDECREF_SET(__pyx_v_overlap, __pyx_t_2);
+            __pyx_t_2 = 0;
+
+            /* "bbox.pyx":234
+ *                                   *(boxes[n, 3] - boxes[n, 1] + 1))
+ *                         overlap = iw * ih / ua
+ *                         if overlap > max_overlaps[n]:             # <<<<<<<<<<<<<<
+ *                             if query_boxes[gt_assignment[n], 4] == -1 or max_overlaps[n] < FG_THRESH:
+ *                                 max_overlaps[n] = overlap
+ */
+            __pyx_t_52 = __pyx_v_n;
+            __pyx_t_12 = -1;
+            if (unlikely(__pyx_t_52 >= (size_t)__pyx_pybuffernd_max_overlaps.diminfo[0].shape)) __pyx_t_12 = 0;
+            if (unlikely(__pyx_t_12 != -1)) {
+              __Pyx_RaiseBufferIndexError(__pyx_t_12);
+              __PYX_ERR(0, 234, __pyx_L1_error)
+            }
+            __pyx_t_2 = PyFloat_FromDouble((*__Pyx_BufPtrStrided1d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_max_overlaps.rcbuffer->pybuffer.buf, __pyx_t_52, __pyx_pybuffernd_max_overlaps.diminfo[0].strides))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 234, __pyx_L1_error)
+            __Pyx_GOTREF(__pyx_t_2);
+            __pyx_t_1 = PyObject_RichCompare(__pyx_v_overlap, __pyx_t_2, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 234, __pyx_L1_error)
+            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+            __pyx_t_33 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_33 < 0)) __PYX_ERR(0, 234, __pyx_L1_error)
+            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+            if (__pyx_t_33) {
+
+              /* "bbox.pyx":235
+ *                         overlap = iw * ih / ua
+ *                         if overlap > max_overlaps[n]:
+ *                             if query_boxes[gt_assignment[n], 4] == -1 or max_overlaps[n] < FG_THRESH:             # <<<<<<<<<<<<<<
+ *                                 max_overlaps[n] = overlap
+ *                                 gt_assignment[n] = k
+ */
+              __pyx_t_53 = __pyx_v_n;
+              __pyx_t_12 = -1;
+              if (unlikely(__pyx_t_53 >= (size_t)__pyx_pybuffernd_gt_assignment.diminfo[0].shape)) __pyx_t_12 = 0;
+              if (unlikely(__pyx_t_12 != -1)) {
+                __Pyx_RaiseBufferIndexError(__pyx_t_12);
+                __PYX_ERR(0, 235, __pyx_L1_error)
+              }
+              __pyx_t_54 = (*__Pyx_BufPtrStrided1d(long *, __pyx_pybuffernd_gt_assignment.rcbuffer->pybuffer.buf, __pyx_t_53, __pyx_pybuffernd_gt_assignment.diminfo[0].strides));
+              __pyx_t_55 = 4;
+              __pyx_t_12 = -1;
+              if (__pyx_t_54 < 0) {
+                __pyx_t_54 += __pyx_pybuffernd_query_boxes.diminfo[0].shape;
+                if (unlikely(__pyx_t_54 < 0)) __pyx_t_12 = 0;
+              } else if (unlikely(__pyx_t_54 >= __pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_12 = 0;
+              if (__pyx_t_55 < 0) {
+                __pyx_t_55 += __pyx_pybuffernd_query_boxes.diminfo[1].shape;
+                if (unlikely(__pyx_t_55 < 0)) __pyx_t_12 = 1;
+              } else if (unlikely(__pyx_t_55 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_12 = 1;
+              if (unlikely(__pyx_t_12 != -1)) {
+                __Pyx_RaiseBufferIndexError(__pyx_t_12);
+                __PYX_ERR(0, 235, __pyx_L1_error)
+              }
+              __pyx_t_56 = (((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_54, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_55, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) == -1.0) != 0);
+              if (!__pyx_t_56) {
+              } else {
+                __pyx_t_33 = __pyx_t_56;
+                goto __pyx_L12_bool_binop_done;
+              }
+              __pyx_t_57 = __pyx_v_n;
+              __pyx_t_12 = -1;
+              if (unlikely(__pyx_t_57 >= (size_t)__pyx_pybuffernd_max_overlaps.diminfo[0].shape)) __pyx_t_12 = 0;
+              if (unlikely(__pyx_t_12 != -1)) {
+                __Pyx_RaiseBufferIndexError(__pyx_t_12);
+                __PYX_ERR(0, 235, __pyx_L1_error)
+              }
+              __pyx_t_56 = (((*__Pyx_BufPtrStrided1d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_max_overlaps.rcbuffer->pybuffer.buf, __pyx_t_57, __pyx_pybuffernd_max_overlaps.diminfo[0].strides)) < __pyx_v_FG_THRESH) != 0);
+              __pyx_t_33 = __pyx_t_56;
+              __pyx_L12_bool_binop_done:;
+              if (__pyx_t_33) {
+
+                /* "bbox.pyx":236
+ *                         if overlap > max_overlaps[n]:
+ *                             if query_boxes[gt_assignment[n], 4] == -1 or max_overlaps[n] < FG_THRESH:
+ *                                 max_overlaps[n] = overlap             # <<<<<<<<<<<<<<
+ *                                 gt_assignment[n] = k
+ *                     else:
+ */
+                __pyx_t_26 = __pyx_PyFloat_AsDouble(__pyx_v_overlap); if (unlikely((__pyx_t_26 == ((npy_double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 236, __pyx_L1_error)
+                __pyx_t_58 = __pyx_v_n;
+                __pyx_t_12 = -1;
+                if (unlikely(__pyx_t_58 >= (size_t)__pyx_pybuffernd_max_overlaps.diminfo[0].shape)) __pyx_t_12 = 0;
+                if (unlikely(__pyx_t_12 != -1)) {
+                  __Pyx_RaiseBufferIndexError(__pyx_t_12);
+                  __PYX_ERR(0, 236, __pyx_L1_error)
+                }
+                *__Pyx_BufPtrStrided1d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_max_overlaps.rcbuffer->pybuffer.buf, __pyx_t_58, __pyx_pybuffernd_max_overlaps.diminfo[0].strides) = __pyx_t_26;
+
+                /* "bbox.pyx":237
+ *                             if query_boxes[gt_assignment[n], 4] == -1 or max_overlaps[n] < FG_THRESH:
+ *                                 max_overlaps[n] = overlap
+ *                                 gt_assignment[n] = k             # <<<<<<<<<<<<<<
+ *                     else:
+ *                         ua = float(
+ */
+                __pyx_t_59 = __pyx_v_n;
+                __pyx_t_12 = -1;
+                if (unlikely(__pyx_t_59 >= (size_t)__pyx_pybuffernd_gt_assignment.diminfo[0].shape)) __pyx_t_12 = 0;
+                if (unlikely(__pyx_t_12 != -1)) {
+                  __Pyx_RaiseBufferIndexError(__pyx_t_12);
+                  __PYX_ERR(0, 237, __pyx_L1_error)
+                }
+                *__Pyx_BufPtrStrided1d(long *, __pyx_pybuffernd_gt_assignment.rcbuffer->pybuffer.buf, __pyx_t_59, __pyx_pybuffernd_gt_assignment.diminfo[0].strides) = __pyx_v_k;
+
+                /* "bbox.pyx":235
+ *                         overlap = iw * ih / ua
+ *                         if overlap > max_overlaps[n]:
+ *                             if query_boxes[gt_assignment[n], 4] == -1 or max_overlaps[n] < FG_THRESH:             # <<<<<<<<<<<<<<
+ *                                 max_overlaps[n] = overlap
+ *                                 gt_assignment[n] = k
+ */
+              }
+
+              /* "bbox.pyx":234
+ *                                   *(boxes[n, 3] - boxes[n, 1] + 1))
+ *                         overlap = iw * ih / ua
+ *                         if overlap > max_overlaps[n]:             # <<<<<<<<<<<<<<
+ *                             if query_boxes[gt_assignment[n], 4] == -1 or max_overlaps[n] < FG_THRESH:
+ *                                 max_overlaps[n] = overlap
+ */
+            }
+
+            /* "bbox.pyx":230
+ *                 )
+ *                 if ih > 0:
+ *                     if query_boxes[k, 4] == -1:             # <<<<<<<<<<<<<<
+ *                         ua = float((boxes[n, 2] - boxes[n, 0] + 1)
+ *                                   *(boxes[n, 3] - boxes[n, 1] + 1))
+ */
+            goto __pyx_L9;
+          }
+
+          /* "bbox.pyx":239
+ *                                 gt_assignment[n] = k
+ *                     else:
+ *                         ua = float(             # <<<<<<<<<<<<<<
+ *                             (boxes[n, 2] - boxes[n, 0] + 1) *
+ *                             (boxes[n, 3] - boxes[n, 1] + 1) +
+ */
+          /*else*/ {
+
+            /* "bbox.pyx":240
+ *                     else:
+ *                         ua = float(
+ *                             (boxes[n, 2] - boxes[n, 0] + 1) *             # <<<<<<<<<<<<<<
+ *                             (boxes[n, 3] - boxes[n, 1] + 1) +
+ *                             box_area - iw * ih
+ */
+            __pyx_t_60 = __pyx_v_n;
+            __pyx_t_61 = 2;
+            __pyx_t_12 = -1;
+            if (unlikely(__pyx_t_60 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_12 = 0;
+            if (__pyx_t_61 < 0) {
+              __pyx_t_61 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+              if (unlikely(__pyx_t_61 < 0)) __pyx_t_12 = 1;
+            } else if (unlikely(__pyx_t_61 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_12 = 1;
+            if (unlikely(__pyx_t_12 != -1)) {
+              __Pyx_RaiseBufferIndexError(__pyx_t_12);
+              __PYX_ERR(0, 240, __pyx_L1_error)
+            }
+            __pyx_t_62 = __pyx_v_n;
+            __pyx_t_63 = 0;
+            __pyx_t_12 = -1;
+            if (unlikely(__pyx_t_62 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_12 = 0;
+            if (__pyx_t_63 < 0) {
+              __pyx_t_63 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+              if (unlikely(__pyx_t_63 < 0)) __pyx_t_12 = 1;
+            } else if (unlikely(__pyx_t_63 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_12 = 1;
+            if (unlikely(__pyx_t_12 != -1)) {
+              __Pyx_RaiseBufferIndexError(__pyx_t_12);
+              __PYX_ERR(0, 240, __pyx_L1_error)
+            }
+
+            /* "bbox.pyx":241
+ *                         ua = float(
+ *                             (boxes[n, 2] - boxes[n, 0] + 1) *
+ *                             (boxes[n, 3] - boxes[n, 1] + 1) +             # <<<<<<<<<<<<<<
+ *                             box_area - iw * ih
+ *                         )
+ */
+            __pyx_t_64 = __pyx_v_n;
+            __pyx_t_65 = 3;
+            __pyx_t_12 = -1;
+            if (unlikely(__pyx_t_64 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_12 = 0;
+            if (__pyx_t_65 < 0) {
+              __pyx_t_65 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+              if (unlikely(__pyx_t_65 < 0)) __pyx_t_12 = 1;
+            } else if (unlikely(__pyx_t_65 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_12 = 1;
+            if (unlikely(__pyx_t_12 != -1)) {
+              __Pyx_RaiseBufferIndexError(__pyx_t_12);
+              __PYX_ERR(0, 241, __pyx_L1_error)
+            }
+            __pyx_t_66 = __pyx_v_n;
+            __pyx_t_67 = 1;
+            __pyx_t_12 = -1;
+            if (unlikely(__pyx_t_66 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_12 = 0;
+            if (__pyx_t_67 < 0) {
+              __pyx_t_67 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+              if (unlikely(__pyx_t_67 < 0)) __pyx_t_12 = 1;
+            } else if (unlikely(__pyx_t_67 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_12 = 1;
+            if (unlikely(__pyx_t_12 != -1)) {
+              __Pyx_RaiseBufferIndexError(__pyx_t_12);
+              __PYX_ERR(0, 241, __pyx_L1_error)
+            }
+
+            /* "bbox.pyx":239
+ *                                 gt_assignment[n] = k
+ *                     else:
+ *                         ua = float(             # <<<<<<<<<<<<<<
+ *                             (boxes[n, 2] - boxes[n, 0] + 1) *
+ *                             (boxes[n, 3] - boxes[n, 1] + 1) +
+ */
+            __pyx_v_ua = ((double)((((((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_60, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_61, __pyx_pybuffernd_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_62, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_63, __pyx_pybuffernd_boxes.diminfo[1].strides))) + 1.0) * (((*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_64, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_65, __pyx_pybuffernd_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_66, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_67, __pyx_pybuffernd_boxes.diminfo[1].strides))) + 1.0)) + __pyx_v_box_area) - (__pyx_v_iw * __pyx_v_ih)));
+
+            /* "bbox.pyx":244
+ *                             box_area - iw * ih
+ *                         )
+ *                         overlap = iw * ih / ua             # <<<<<<<<<<<<<<
+ *                         if overlap > max_overlaps[n]:
+ *                             max_overlaps[n] = overlap
+ */
+            __pyx_t_26 = (__pyx_v_iw * __pyx_v_ih);
+            if (unlikely(__pyx_v_ua == 0)) {
+              PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+              __PYX_ERR(0, 244, __pyx_L1_error)
+            }
+            __pyx_t_1 = PyFloat_FromDouble((__pyx_t_26 / __pyx_v_ua)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 244, __pyx_L1_error)
+            __Pyx_GOTREF(__pyx_t_1);
+            __Pyx_XDECREF_SET(__pyx_v_overlap, __pyx_t_1);
+            __pyx_t_1 = 0;
+
+            /* "bbox.pyx":245
+ *                         )
+ *                         overlap = iw * ih / ua
+ *                         if overlap > max_overlaps[n]:             # <<<<<<<<<<<<<<
+ *                             max_overlaps[n] = overlap
+ *                             gt_assignment[n] = k
+ */
+            __pyx_t_68 = __pyx_v_n;
+            __pyx_t_12 = -1;
+            if (unlikely(__pyx_t_68 >= (size_t)__pyx_pybuffernd_max_overlaps.diminfo[0].shape)) __pyx_t_12 = 0;
+            if (unlikely(__pyx_t_12 != -1)) {
+              __Pyx_RaiseBufferIndexError(__pyx_t_12);
+              __PYX_ERR(0, 245, __pyx_L1_error)
+            }
+            __pyx_t_1 = PyFloat_FromDouble((*__Pyx_BufPtrStrided1d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_max_overlaps.rcbuffer->pybuffer.buf, __pyx_t_68, __pyx_pybuffernd_max_overlaps.diminfo[0].strides))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 245, __pyx_L1_error)
+            __Pyx_GOTREF(__pyx_t_1);
+            __pyx_t_2 = PyObject_RichCompare(__pyx_v_overlap, __pyx_t_1, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 245, __pyx_L1_error)
+            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+            __pyx_t_33 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_33 < 0)) __PYX_ERR(0, 245, __pyx_L1_error)
+            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+            if (__pyx_t_33) {
+
+              /* "bbox.pyx":246
+ *                         overlap = iw * ih / ua
+ *                         if overlap > max_overlaps[n]:
+ *                             max_overlaps[n] = overlap             # <<<<<<<<<<<<<<
+ *                             gt_assignment[n] = k
+ *                     #overlaps[n, k] = overlap
+ */
+              __pyx_t_26 = __pyx_PyFloat_AsDouble(__pyx_v_overlap); if (unlikely((__pyx_t_26 == ((npy_double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 246, __pyx_L1_error)
+              __pyx_t_69 = __pyx_v_n;
+              __pyx_t_12 = -1;
+              if (unlikely(__pyx_t_69 >= (size_t)__pyx_pybuffernd_max_overlaps.diminfo[0].shape)) __pyx_t_12 = 0;
+              if (unlikely(__pyx_t_12 != -1)) {
+                __Pyx_RaiseBufferIndexError(__pyx_t_12);
+                __PYX_ERR(0, 246, __pyx_L1_error)
+              }
+              *__Pyx_BufPtrStrided1d(__pyx_t_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_max_overlaps.rcbuffer->pybuffer.buf, __pyx_t_69, __pyx_pybuffernd_max_overlaps.diminfo[0].strides) = __pyx_t_26;
+
+              /* "bbox.pyx":247
+ *                         if overlap > max_overlaps[n]:
+ *                             max_overlaps[n] = overlap
+ *                             gt_assignment[n] = k             # <<<<<<<<<<<<<<
+ *                     #overlaps[n, k] = overlap
+ *     return gt_assignment, max_overlaps
+ */
+              __pyx_t_70 = __pyx_v_n;
+              __pyx_t_12 = -1;
+              if (unlikely(__pyx_t_70 >= (size_t)__pyx_pybuffernd_gt_assignment.diminfo[0].shape)) __pyx_t_12 = 0;
+              if (unlikely(__pyx_t_12 != -1)) {
+                __Pyx_RaiseBufferIndexError(__pyx_t_12);
+                __PYX_ERR(0, 247, __pyx_L1_error)
+              }
+              *__Pyx_BufPtrStrided1d(long *, __pyx_pybuffernd_gt_assignment.rcbuffer->pybuffer.buf, __pyx_t_70, __pyx_pybuffernd_gt_assignment.diminfo[0].strides) = __pyx_v_k;
+
+              /* "bbox.pyx":245
+ *                         )
+ *                         overlap = iw * ih / ua
+ *                         if overlap > max_overlaps[n]:             # <<<<<<<<<<<<<<
+ *                             max_overlaps[n] = overlap
+ *                             gt_assignment[n] = k
+ */
+            }
+          }
+          __pyx_L9:;
+
+          /* "bbox.pyx":229
+ *                     max(boxes[n, 1], query_boxes[k, 1]) + 1
+ *                 )
+ *                 if ih > 0:             # <<<<<<<<<<<<<<
+ *                     if query_boxes[k, 4] == -1:
+ *                         ua = float((boxes[n, 2] - boxes[n, 0] + 1)
+ */
+        }
+
+        /* "bbox.pyx":224
+ *                 max(boxes[n, 0], query_boxes[k, 0]) + 1
+ *             )
+ *             if iw > 0:             # <<<<<<<<<<<<<<
+ *                 ih = (
+ *                     min(boxes[n, 3], query_boxes[k, 3]) -
+ */
+      }
+    }
+  }
+
+  /* "bbox.pyx":249
+ *                             gt_assignment[n] = k
+ *                     #overlaps[n, k] = overlap
+ *     return gt_assignment, max_overlaps             # <<<<<<<<<<<<<<
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 249, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(((PyObject *)__pyx_v_gt_assignment));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_gt_assignment));
+  PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)__pyx_v_gt_assignment));
+  __Pyx_INCREF(((PyObject *)__pyx_v_max_overlaps));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_max_overlaps));
+  PyTuple_SET_ITEM(__pyx_t_2, 1, ((PyObject *)__pyx_v_max_overlaps));
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "bbox.pyx":194
+ * 
+ * 
+ * def get_assignment_overlaps(             # <<<<<<<<<<<<<<
+ *         np.ndarray[DTYPE_t, ndim=2] boxes,
+ *         np.ndarray[DTYPE_t, ndim=2] query_boxes,
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_gt_assignment.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_max_overlaps.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("cython_bbox.get_assignment_overlaps", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_gt_assignment.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_max_overlaps.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_gt_assignment);
+  __Pyx_XDECREF((PyObject *)__pyx_v_max_overlaps);
+  __Pyx_XDECREF(__pyx_v_overlap);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":197
+ *         # experimental exception made for __getbuffer__ and __releasebuffer__
+ *         # -- the details of this may change.
+ *         def __getbuffer__(ndarray self, Py_buffer* info, int flags):             # <<<<<<<<<<<<<<
+ *             # This implementation of getbuffer is geared towards Cython
+ *             # requirements, and does not yet fullfill the PEP.
+ */
+
+/* Python wrapper */
+static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
+static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
+  int __pyx_v_copy_shape;
+  int __pyx_v_i;
+  int __pyx_v_ndim;
+  int __pyx_v_endian_detector;
+  int __pyx_v_little_endian;
+  int __pyx_v_t;
+  char *__pyx_v_f;
+  PyArray_Descr *__pyx_v_descr = 0;
+  int __pyx_v_offset;
+  int __pyx_v_hasfields;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  char *__pyx_t_7;
+  __Pyx_RefNannySetupContext("__getbuffer__", 0);
+  if (__pyx_v_info != NULL) {
+    __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(__pyx_v_info->obj);
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":203
+ *             # of flags
+ * 
+ *             if info == NULL: return             # <<<<<<<<<<<<<<
+ * 
+ *             cdef int copy_shape, i, ndim
+ */
+  __pyx_t_1 = ((__pyx_v_info == NULL) != 0);
+  if (__pyx_t_1) {
+    __pyx_r = 0;
+    goto __pyx_L0;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":206
+ * 
+ *             cdef int copy_shape, i, ndim
+ *             cdef int endian_detector = 1             # <<<<<<<<<<<<<<
+ *             cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)
+ * 
+ */
+  __pyx_v_endian_detector = 1;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":207
+ *             cdef int copy_shape, i, ndim
+ *             cdef int endian_detector = 1
+ *             cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)             # <<<<<<<<<<<<<<
+ * 
+ *             ndim = PyArray_NDIM(self)
+ */
+  __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":209
+ *             cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)
+ * 
+ *             ndim = PyArray_NDIM(self)             # <<<<<<<<<<<<<<
+ * 
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ */
+  __pyx_v_ndim = PyArray_NDIM(__pyx_v_self);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":211
+ *             ndim = PyArray_NDIM(self)
+ * 
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
+ *                 copy_shape = 1
+ *             else:
+ */
+  __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":212
+ * 
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ *                 copy_shape = 1             # <<<<<<<<<<<<<<
+ *             else:
+ *                 copy_shape = 0
+ */
+    __pyx_v_copy_shape = 1;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":211
+ *             ndim = PyArray_NDIM(self)
+ * 
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
+ *                 copy_shape = 1
+ *             else:
+ */
+    goto __pyx_L4;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":214
+ *                 copy_shape = 1
+ *             else:
+ *                 copy_shape = 0             # <<<<<<<<<<<<<<
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
+ */
+  /*else*/ {
+    __pyx_v_copy_shape = 0;
+  }
+  __pyx_L4:;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216
+ *                 copy_shape = 0
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ */
+  __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L6_bool_binop_done;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":217
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):             # <<<<<<<<<<<<<<
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ * 
+ */
+  __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_C_CONTIGUOUS) != 0)) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L6_bool_binop_done:;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216
+ *                 copy_shape = 0
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ */
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":218
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")             # <<<<<<<<<<<<<<
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 218, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(1, 218, __pyx_L1_error)
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216
+ *                 copy_shape = 0
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ */
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ */
+  __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L9_bool_binop_done;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":221
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):             # <<<<<<<<<<<<<<
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ * 
+ */
+  __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_F_CONTIGUOUS) != 0)) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L9_bool_binop_done:;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ */
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":222
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")             # <<<<<<<<<<<<<<
+ * 
+ *             info.buf = PyArray_DATA(self)
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 222, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(1, 222, __pyx_L1_error)
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ */
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":224
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ * 
+ *             info.buf = PyArray_DATA(self)             # <<<<<<<<<<<<<<
+ *             info.ndim = ndim
+ *             if copy_shape:
+ */
+  __pyx_v_info->buf = PyArray_DATA(__pyx_v_self);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":225
+ * 
+ *             info.buf = PyArray_DATA(self)
+ *             info.ndim = ndim             # <<<<<<<<<<<<<<
+ *             if copy_shape:
+ *                 # Allocate new buffer for strides and shape info.
+ */
+  __pyx_v_info->ndim = __pyx_v_ndim;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":226
+ *             info.buf = PyArray_DATA(self)
+ *             info.ndim = ndim
+ *             if copy_shape:             # <<<<<<<<<<<<<<
+ *                 # Allocate new buffer for strides and shape info.
+ *                 # This is allocated as one block, strides first.
+ */
+  __pyx_t_1 = (__pyx_v_copy_shape != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":229
+ *                 # Allocate new buffer for strides and shape info.
+ *                 # This is allocated as one block, strides first.
+ *                 info.strides = <Py_ssize_t*>stdlib.malloc(sizeof(Py_ssize_t) * <size_t>ndim * 2)             # <<<<<<<<<<<<<<
+ *                 info.shape = info.strides + ndim
+ *                 for i in range(ndim):
+ */
+    __pyx_v_info->strides = ((Py_ssize_t *)malloc((((sizeof(Py_ssize_t)) * ((size_t)__pyx_v_ndim)) * 2)));
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":230
+ *                 # This is allocated as one block, strides first.
+ *                 info.strides = <Py_ssize_t*>stdlib.malloc(sizeof(Py_ssize_t) * <size_t>ndim * 2)
+ *                 info.shape = info.strides + ndim             # <<<<<<<<<<<<<<
+ *                 for i in range(ndim):
+ *                     info.strides[i] = PyArray_STRIDES(self)[i]
+ */
+    __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim);
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":231
+ *                 info.strides = <Py_ssize_t*>stdlib.malloc(sizeof(Py_ssize_t) * <size_t>ndim * 2)
+ *                 info.shape = info.strides + ndim
+ *                 for i in range(ndim):             # <<<<<<<<<<<<<<
+ *                     info.strides[i] = PyArray_STRIDES(self)[i]
+ *                     info.shape[i] = PyArray_DIMS(self)[i]
+ */
+    __pyx_t_4 = __pyx_v_ndim;
+    for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
+      __pyx_v_i = __pyx_t_5;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":232
+ *                 info.shape = info.strides + ndim
+ *                 for i in range(ndim):
+ *                     info.strides[i] = PyArray_STRIDES(self)[i]             # <<<<<<<<<<<<<<
+ *                     info.shape[i] = PyArray_DIMS(self)[i]
+ *             else:
+ */
+      (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]);
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":233
+ *                 for i in range(ndim):
+ *                     info.strides[i] = PyArray_STRIDES(self)[i]
+ *                     info.shape[i] = PyArray_DIMS(self)[i]             # <<<<<<<<<<<<<<
+ *             else:
+ *                 info.strides = <Py_ssize_t*>PyArray_STRIDES(self)
+ */
+      (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]);
+    }
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":226
+ *             info.buf = PyArray_DATA(self)
+ *             info.ndim = ndim
+ *             if copy_shape:             # <<<<<<<<<<<<<<
+ *                 # Allocate new buffer for strides and shape info.
+ *                 # This is allocated as one block, strides first.
+ */
+    goto __pyx_L11;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":235
+ *                     info.shape[i] = PyArray_DIMS(self)[i]
+ *             else:
+ *                 info.strides = <Py_ssize_t*>PyArray_STRIDES(self)             # <<<<<<<<<<<<<<
+ *                 info.shape = <Py_ssize_t*>PyArray_DIMS(self)
+ *             info.suboffsets = NULL
+ */
+  /*else*/ {
+    __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self));
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":236
+ *             else:
+ *                 info.strides = <Py_ssize_t*>PyArray_STRIDES(self)
+ *                 info.shape = <Py_ssize_t*>PyArray_DIMS(self)             # <<<<<<<<<<<<<<
+ *             info.suboffsets = NULL
+ *             info.itemsize = PyArray_ITEMSIZE(self)
+ */
+    __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self));
+  }
+  __pyx_L11:;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":237
+ *                 info.strides = <Py_ssize_t*>PyArray_STRIDES(self)
+ *                 info.shape = <Py_ssize_t*>PyArray_DIMS(self)
+ *             info.suboffsets = NULL             # <<<<<<<<<<<<<<
+ *             info.itemsize = PyArray_ITEMSIZE(self)
+ *             info.readonly = not PyArray_ISWRITEABLE(self)
+ */
+  __pyx_v_info->suboffsets = NULL;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":238
+ *                 info.shape = <Py_ssize_t*>PyArray_DIMS(self)
+ *             info.suboffsets = NULL
+ *             info.itemsize = PyArray_ITEMSIZE(self)             # <<<<<<<<<<<<<<
+ *             info.readonly = not PyArray_ISWRITEABLE(self)
+ * 
+ */
+  __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":239
+ *             info.suboffsets = NULL
+ *             info.itemsize = PyArray_ITEMSIZE(self)
+ *             info.readonly = not PyArray_ISWRITEABLE(self)             # <<<<<<<<<<<<<<
+ * 
+ *             cdef int t
+ */
+  __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0));
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":242
+ * 
+ *             cdef int t
+ *             cdef char* f = NULL             # <<<<<<<<<<<<<<
+ *             cdef dtype descr = self.descr
+ *             cdef int offset
+ */
+  __pyx_v_f = NULL;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":243
+ *             cdef int t
+ *             cdef char* f = NULL
+ *             cdef dtype descr = self.descr             # <<<<<<<<<<<<<<
+ *             cdef int offset
+ * 
+ */
+  __pyx_t_3 = ((PyObject *)__pyx_v_self->descr);
+  __Pyx_INCREF(__pyx_t_3);
+  __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":246
+ *             cdef int offset
+ * 
+ *             cdef bint hasfields = PyDataType_HASFIELDS(descr)             # <<<<<<<<<<<<<<
+ * 
+ *             if not hasfields and not copy_shape:
+ */
+  __pyx_v_hasfields = PyDataType_HASFIELDS(__pyx_v_descr);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":248
+ *             cdef bint hasfields = PyDataType_HASFIELDS(descr)
+ * 
+ *             if not hasfields and not copy_shape:             # <<<<<<<<<<<<<<
+ *                 # do not call releasebuffer
+ *                 info.obj = None
+ */
+  __pyx_t_2 = ((!(__pyx_v_hasfields != 0)) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L15_bool_binop_done;
+  }
+  __pyx_t_2 = ((!(__pyx_v_copy_shape != 0)) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L15_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":250
+ *             if not hasfields and not copy_shape:
+ *                 # do not call releasebuffer
+ *                 info.obj = None             # <<<<<<<<<<<<<<
+ *             else:
+ *                 # need to call releasebuffer
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __Pyx_GOTREF(__pyx_v_info->obj);
+    __Pyx_DECREF(__pyx_v_info->obj);
+    __pyx_v_info->obj = Py_None;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":248
+ *             cdef bint hasfields = PyDataType_HASFIELDS(descr)
+ * 
+ *             if not hasfields and not copy_shape:             # <<<<<<<<<<<<<<
+ *                 # do not call releasebuffer
+ *                 info.obj = None
+ */
+    goto __pyx_L14;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":253
+ *             else:
+ *                 # need to call releasebuffer
+ *                 info.obj = self             # <<<<<<<<<<<<<<
+ * 
+ *             if not hasfields:
+ */
+  /*else*/ {
+    __Pyx_INCREF(((PyObject *)__pyx_v_self));
+    __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+    __Pyx_GOTREF(__pyx_v_info->obj);
+    __Pyx_DECREF(__pyx_v_info->obj);
+    __pyx_v_info->obj = ((PyObject *)__pyx_v_self);
+  }
+  __pyx_L14:;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":255
+ *                 info.obj = self
+ * 
+ *             if not hasfields:             # <<<<<<<<<<<<<<
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ */
+  __pyx_t_1 = ((!(__pyx_v_hasfields != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":256
+ * 
+ *             if not hasfields:
+ *                 t = descr.type_num             # <<<<<<<<<<<<<<
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ */
+    __pyx_t_4 = __pyx_v_descr->type_num;
+    __pyx_v_t = __pyx_t_4;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257
+ *             if not hasfields:
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")
+ */
+    __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0);
+    if (!__pyx_t_2) {
+      goto __pyx_L20_next_or;
+    } else {
+    }
+    __pyx_t_2 = (__pyx_v_little_endian != 0);
+    if (!__pyx_t_2) {
+    } else {
+      __pyx_t_1 = __pyx_t_2;
+      goto __pyx_L19_bool_binop_done;
+    }
+    __pyx_L20_next_or:;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":258
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ *                     (descr.byteorder == c'<' and not little_endian)):             # <<<<<<<<<<<<<<
+ *                     raise ValueError(u"Non-native byte order not supported")
+ *                 if   t == NPY_BYTE:        f = "b"
+ */
+    __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0);
+    if (__pyx_t_2) {
+    } else {
+      __pyx_t_1 = __pyx_t_2;
+      goto __pyx_L19_bool_binop_done;
+    }
+    __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0);
+    __pyx_t_1 = __pyx_t_2;
+    __pyx_L19_bool_binop_done:;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257
+ *             if not hasfields:
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")
+ */
+    if (__pyx_t_1) {
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":259
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
+ *                 if   t == NPY_BYTE:        f = "b"
+ *                 elif t == NPY_UBYTE:       f = "B"
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 259, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(1, 259, __pyx_L1_error)
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257
+ *             if not hasfields:
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")
+ */
+    }
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":260
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")
+ *                 if   t == NPY_BYTE:        f = "b"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_UBYTE:       f = "B"
+ *                 elif t == NPY_SHORT:       f = "h"
+ */
+    switch (__pyx_v_t) {
+      case NPY_BYTE:
+      __pyx_v_f = ((char *)"b");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":261
+ *                     raise ValueError(u"Non-native byte order not supported")
+ *                 if   t == NPY_BYTE:        f = "b"
+ *                 elif t == NPY_UBYTE:       f = "B"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_SHORT:       f = "h"
+ *                 elif t == NPY_USHORT:      f = "H"
+ */
+      case NPY_UBYTE:
+      __pyx_v_f = ((char *)"B");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":262
+ *                 if   t == NPY_BYTE:        f = "b"
+ *                 elif t == NPY_UBYTE:       f = "B"
+ *                 elif t == NPY_SHORT:       f = "h"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_USHORT:      f = "H"
+ *                 elif t == NPY_INT:         f = "i"
+ */
+      case NPY_SHORT:
+      __pyx_v_f = ((char *)"h");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":263
+ *                 elif t == NPY_UBYTE:       f = "B"
+ *                 elif t == NPY_SHORT:       f = "h"
+ *                 elif t == NPY_USHORT:      f = "H"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_INT:         f = "i"
+ *                 elif t == NPY_UINT:        f = "I"
+ */
+      case NPY_USHORT:
+      __pyx_v_f = ((char *)"H");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":264
+ *                 elif t == NPY_SHORT:       f = "h"
+ *                 elif t == NPY_USHORT:      f = "H"
+ *                 elif t == NPY_INT:         f = "i"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_UINT:        f = "I"
+ *                 elif t == NPY_LONG:        f = "l"
+ */
+      case NPY_INT:
+      __pyx_v_f = ((char *)"i");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":265
+ *                 elif t == NPY_USHORT:      f = "H"
+ *                 elif t == NPY_INT:         f = "i"
+ *                 elif t == NPY_UINT:        f = "I"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_LONG:        f = "l"
+ *                 elif t == NPY_ULONG:       f = "L"
+ */
+      case NPY_UINT:
+      __pyx_v_f = ((char *)"I");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":266
+ *                 elif t == NPY_INT:         f = "i"
+ *                 elif t == NPY_UINT:        f = "I"
+ *                 elif t == NPY_LONG:        f = "l"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_ULONG:       f = "L"
+ *                 elif t == NPY_LONGLONG:    f = "q"
+ */
+      case NPY_LONG:
+      __pyx_v_f = ((char *)"l");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":267
+ *                 elif t == NPY_UINT:        f = "I"
+ *                 elif t == NPY_LONG:        f = "l"
+ *                 elif t == NPY_ULONG:       f = "L"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_LONGLONG:    f = "q"
+ *                 elif t == NPY_ULONGLONG:   f = "Q"
+ */
+      case NPY_ULONG:
+      __pyx_v_f = ((char *)"L");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":268
+ *                 elif t == NPY_LONG:        f = "l"
+ *                 elif t == NPY_ULONG:       f = "L"
+ *                 elif t == NPY_LONGLONG:    f = "q"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_ULONGLONG:   f = "Q"
+ *                 elif t == NPY_FLOAT:       f = "f"
+ */
+      case NPY_LONGLONG:
+      __pyx_v_f = ((char *)"q");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":269
+ *                 elif t == NPY_ULONG:       f = "L"
+ *                 elif t == NPY_LONGLONG:    f = "q"
+ *                 elif t == NPY_ULONGLONG:   f = "Q"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_FLOAT:       f = "f"
+ *                 elif t == NPY_DOUBLE:      f = "d"
+ */
+      case NPY_ULONGLONG:
+      __pyx_v_f = ((char *)"Q");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":270
+ *                 elif t == NPY_LONGLONG:    f = "q"
+ *                 elif t == NPY_ULONGLONG:   f = "Q"
+ *                 elif t == NPY_FLOAT:       f = "f"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_DOUBLE:      f = "d"
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"
+ */
+      case NPY_FLOAT:
+      __pyx_v_f = ((char *)"f");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":271
+ *                 elif t == NPY_ULONGLONG:   f = "Q"
+ *                 elif t == NPY_FLOAT:       f = "f"
+ *                 elif t == NPY_DOUBLE:      f = "d"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"
+ *                 elif t == NPY_CFLOAT:      f = "Zf"
+ */
+      case NPY_DOUBLE:
+      __pyx_v_f = ((char *)"d");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":272
+ *                 elif t == NPY_FLOAT:       f = "f"
+ *                 elif t == NPY_DOUBLE:      f = "d"
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_CFLOAT:      f = "Zf"
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"
+ */
+      case NPY_LONGDOUBLE:
+      __pyx_v_f = ((char *)"g");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":273
+ *                 elif t == NPY_DOUBLE:      f = "d"
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"
+ *                 elif t == NPY_CFLOAT:      f = "Zf"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"
+ *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
+ */
+      case NPY_CFLOAT:
+      __pyx_v_f = ((char *)"Zf");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":274
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"
+ *                 elif t == NPY_CFLOAT:      f = "Zf"
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
+ *                 elif t == NPY_OBJECT:      f = "O"
+ */
+      case NPY_CDOUBLE:
+      __pyx_v_f = ((char *)"Zd");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":275
+ *                 elif t == NPY_CFLOAT:      f = "Zf"
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"
+ *                 elif t == NPY_CLONGDOUBLE: f = "Zg"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_OBJECT:      f = "O"
+ *                 else:
+ */
+      case NPY_CLONGDOUBLE:
+      __pyx_v_f = ((char *)"Zg");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":276
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"
+ *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
+ *                 elif t == NPY_OBJECT:      f = "O"             # <<<<<<<<<<<<<<
+ *                 else:
+ *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ */
+      case NPY_OBJECT:
+      __pyx_v_f = ((char *)"O");
+      break;
+      default:
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":278
+ *                 elif t == NPY_OBJECT:      f = "O"
+ *                 else:
+ *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)             # <<<<<<<<<<<<<<
+ *                 info.format = f
+ *                 return
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 278, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_6 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 278, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 278, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_GIVEREF(__pyx_t_6);
+      PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6);
+      __pyx_t_6 = 0;
+      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 278, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_Raise(__pyx_t_6, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __PYX_ERR(1, 278, __pyx_L1_error)
+      break;
+    }
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":279
+ *                 else:
+ *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ *                 info.format = f             # <<<<<<<<<<<<<<
+ *                 return
+ *             else:
+ */
+    __pyx_v_info->format = __pyx_v_f;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":280
+ *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ *                 info.format = f
+ *                 return             # <<<<<<<<<<<<<<
+ *             else:
+ *                 info.format = <char*>stdlib.malloc(_buffer_format_string_len)
+ */
+    __pyx_r = 0;
+    goto __pyx_L0;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":255
+ *                 info.obj = self
+ * 
+ *             if not hasfields:             # <<<<<<<<<<<<<<
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ */
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":282
+ *                 return
+ *             else:
+ *                 info.format = <char*>stdlib.malloc(_buffer_format_string_len)             # <<<<<<<<<<<<<<
+ *                 info.format[0] = c'^' # Native data types, manual alignment
+ *                 offset = 0
+ */
+  /*else*/ {
+    __pyx_v_info->format = ((char *)malloc(0xFF));
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":283
+ *             else:
+ *                 info.format = <char*>stdlib.malloc(_buffer_format_string_len)
+ *                 info.format[0] = c'^' # Native data types, manual alignment             # <<<<<<<<<<<<<<
+ *                 offset = 0
+ *                 f = _util_dtypestring(descr, info.format + 1,
+ */
+    (__pyx_v_info->format[0]) = '^';
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":284
+ *                 info.format = <char*>stdlib.malloc(_buffer_format_string_len)
+ *                 info.format[0] = c'^' # Native data types, manual alignment
+ *                 offset = 0             # <<<<<<<<<<<<<<
+ *                 f = _util_dtypestring(descr, info.format + 1,
+ *                                       info.format + _buffer_format_string_len,
+ */
+    __pyx_v_offset = 0;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":285
+ *                 info.format[0] = c'^' # Native data types, manual alignment
+ *                 offset = 0
+ *                 f = _util_dtypestring(descr, info.format + 1,             # <<<<<<<<<<<<<<
+ *                                       info.format + _buffer_format_string_len,
+ *                                       &offset)
+ */
+    __pyx_t_7 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_7 == NULL)) __PYX_ERR(1, 285, __pyx_L1_error)
+    __pyx_v_f = __pyx_t_7;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":288
+ *                                       info.format + _buffer_format_string_len,
+ *                                       &offset)
+ *                 f[0] = c'\0' # Terminate format string             # <<<<<<<<<<<<<<
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):
+ */
+    (__pyx_v_f[0]) = '\x00';
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":197
+ *         # experimental exception made for __getbuffer__ and __releasebuffer__
+ *         # -- the details of this may change.
+ *         def __getbuffer__(ndarray self, Py_buffer* info, int flags):             # <<<<<<<<<<<<<<
+ *             # This implementation of getbuffer is geared towards Cython
+ *             # requirements, and does not yet fullfill the PEP.
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  if (__pyx_v_info != NULL && __pyx_v_info->obj != NULL) {
+    __Pyx_GOTREF(__pyx_v_info->obj);
+    __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = NULL;
+  }
+  goto __pyx_L2;
+  __pyx_L0:;
+  if (__pyx_v_info != NULL && __pyx_v_info->obj == Py_None) {
+    __Pyx_GOTREF(Py_None);
+    __Pyx_DECREF(Py_None); __pyx_v_info->obj = NULL;
+  }
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_descr);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":290
+ *                 f[0] = c'\0' # Terminate format string
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):             # <<<<<<<<<<<<<<
+ *             if PyArray_HASFIELDS(self):
+ *                 stdlib.free(info.format)
+ */
+
+/* Python wrapper */
+static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/
+static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0);
+  __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) {
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("__releasebuffer__", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":291
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):
+ *             if PyArray_HASFIELDS(self):             # <<<<<<<<<<<<<<
+ *                 stdlib.free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ */
+  __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":292
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):
+ *             if PyArray_HASFIELDS(self):
+ *                 stdlib.free(info.format)             # <<<<<<<<<<<<<<
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ *                 stdlib.free(info.strides)
+ */
+    free(__pyx_v_info->format);
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":291
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):
+ *             if PyArray_HASFIELDS(self):             # <<<<<<<<<<<<<<
+ *                 stdlib.free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ */
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":293
+ *             if PyArray_HASFIELDS(self):
+ *                 stdlib.free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
+ *                 stdlib.free(info.strides)
+ *                 # info.shape was stored after info.strides in the same block
+ */
+  __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":294
+ *                 stdlib.free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ *                 stdlib.free(info.strides)             # <<<<<<<<<<<<<<
+ *                 # info.shape was stored after info.strides in the same block
+ * 
+ */
+    free(__pyx_v_info->strides);
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":293
+ *             if PyArray_HASFIELDS(self):
+ *                 stdlib.free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
+ *                 stdlib.free(info.strides)
+ *                 # info.shape was stored after info.strides in the same block
+ */
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":290
+ *                 f[0] = c'\0' # Terminate format string
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):             # <<<<<<<<<<<<<<
+ *             if PyArray_HASFIELDS(self):
+ *                 stdlib.free(info.format)
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":770
+ * ctypedef npy_cdouble     complex_t
+ * 
+ * cdef inline object PyArray_MultiIterNew1(a):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(1, <void*>a)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":771
+ * 
+ * cdef inline object PyArray_MultiIterNew1(a):
+ *     return PyArray_MultiIterNew(1, <void*>a)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew2(a, b):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 771, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":770
+ * ctypedef npy_cdouble     complex_t
+ * 
+ * cdef inline object PyArray_MultiIterNew1(a):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(1, <void*>a)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":773
+ *     return PyArray_MultiIterNew(1, <void*>a)
+ * 
+ * cdef inline object PyArray_MultiIterNew2(a, b):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(2, <void*>a, <void*>b)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":774
+ * 
+ * cdef inline object PyArray_MultiIterNew2(a, b):
+ *     return PyArray_MultiIterNew(2, <void*>a, <void*>b)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew3(a, b, c):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 774, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":773
+ *     return PyArray_MultiIterNew(1, <void*>a)
+ * 
+ * cdef inline object PyArray_MultiIterNew2(a, b):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(2, <void*>a, <void*>b)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":776
+ *     return PyArray_MultiIterNew(2, <void*>a, <void*>b)
+ * 
+ * cdef inline object PyArray_MultiIterNew3(a, b, c):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":777
+ * 
+ * cdef inline object PyArray_MultiIterNew3(a, b, c):
+ *     return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew4(a, b, c, d):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 777, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":776
+ *     return PyArray_MultiIterNew(2, <void*>a, <void*>b)
+ * 
+ * cdef inline object PyArray_MultiIterNew3(a, b, c):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":779
+ *     return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
+ * 
+ * cdef inline object PyArray_MultiIterNew4(a, b, c, d):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":780
+ * 
+ * cdef inline object PyArray_MultiIterNew4(a, b, c, d):
+ *     return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 780, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":779
+ *     return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
+ * 
+ * cdef inline object PyArray_MultiIterNew4(a, b, c, d):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":782
+ *     return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
+ * 
+ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":783
+ * 
+ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
+ *     return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 783, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":782
+ *     return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
+ * 
+ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":785
+ *     return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
+ * 
+ * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:             # <<<<<<<<<<<<<<
+ *     # Recursive utility function used in __getbuffer__ to get format
+ *     # string. The new location in the format string is returned.
+ */
+
+static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) {
+  PyArray_Descr *__pyx_v_child = 0;
+  int __pyx_v_endian_detector;
+  int __pyx_v_little_endian;
+  PyObject *__pyx_v_fields = 0;
+  PyObject *__pyx_v_childname = NULL;
+  PyObject *__pyx_v_new_offset = NULL;
+  PyObject *__pyx_v_t = NULL;
+  char *__pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  Py_ssize_t __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  int __pyx_t_6;
+  int __pyx_t_7;
+  long __pyx_t_8;
+  char *__pyx_t_9;
+  __Pyx_RefNannySetupContext("_util_dtypestring", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":790
+ * 
+ *     cdef dtype child
+ *     cdef int endian_detector = 1             # <<<<<<<<<<<<<<
+ *     cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)
+ *     cdef tuple fields
+ */
+  __pyx_v_endian_detector = 1;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":791
+ *     cdef dtype child
+ *     cdef int endian_detector = 1
+ *     cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)             # <<<<<<<<<<<<<<
+ *     cdef tuple fields
+ * 
+ */
+  __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":794
+ *     cdef tuple fields
+ * 
+ *     for childname in descr.names:             # <<<<<<<<<<<<<<
+ *         fields = descr.fields[childname]
+ *         child, new_offset = fields
+ */
+  if (unlikely(__pyx_v_descr->names == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+    __PYX_ERR(1, 794, __pyx_L1_error)
+  }
+  __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
+  for (;;) {
+    if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 794, __pyx_L1_error)
+    #else
+    __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 794, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    #endif
+    __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":795
+ * 
+ *     for childname in descr.names:
+ *         fields = descr.fields[childname]             # <<<<<<<<<<<<<<
+ *         child, new_offset = fields
+ * 
+ */
+    if (unlikely(__pyx_v_descr->fields == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(1, 795, __pyx_L1_error)
+    }
+    __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 795, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 795, __pyx_L1_error)
+    __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3));
+    __pyx_t_3 = 0;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":796
+ *     for childname in descr.names:
+ *         fields = descr.fields[childname]
+ *         child, new_offset = fields             # <<<<<<<<<<<<<<
+ * 
+ *         if (end - f) - <int>(new_offset - offset[0]) < 15:
+ */
+    if (likely(__pyx_v_fields != Py_None)) {
+      PyObject* sequence = __pyx_v_fields;
+      #if !CYTHON_COMPILING_IN_PYPY
+      Py_ssize_t size = Py_SIZE(sequence);
+      #else
+      Py_ssize_t size = PySequence_Size(sequence);
+      #endif
+      if (unlikely(size != 2)) {
+        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+        __PYX_ERR(1, 796, __pyx_L1_error)
+      }
+      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); 
+      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); 
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_4);
+      #else
+      __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 796, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 796, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      #endif
+    } else {
+      __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 796, __pyx_L1_error)
+    }
+    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 796, __pyx_L1_error)
+    __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3));
+    __pyx_t_3 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":798
+ *         child, new_offset = fields
+ * 
+ *         if (end - f) - <int>(new_offset - offset[0]) < 15:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 798, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 798, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 798, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0);
+    if (__pyx_t_6) {
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":799
+ * 
+ *         if (end - f) - <int>(new_offset - offset[0]) < 15:
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")             # <<<<<<<<<<<<<<
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 799, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(1, 799, __pyx_L1_error)
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":798
+ *         child, new_offset = fields
+ * 
+ *         if (end - f) - <int>(new_offset - offset[0]) < 15:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ */
+    }
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")
+ */
+    __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0);
+    if (!__pyx_t_7) {
+      goto __pyx_L8_next_or;
+    } else {
+    }
+    __pyx_t_7 = (__pyx_v_little_endian != 0);
+    if (!__pyx_t_7) {
+    } else {
+      __pyx_t_6 = __pyx_t_7;
+      goto __pyx_L7_bool_binop_done;
+    }
+    __pyx_L8_next_or:;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":802
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or
+ *             (child.byteorder == c'<' and not little_endian)):             # <<<<<<<<<<<<<<
+ *             raise ValueError(u"Non-native byte order not supported")
+ *             # One could encode it in the format string and have Cython
+ */
+    __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0);
+    if (__pyx_t_7) {
+    } else {
+      __pyx_t_6 = __pyx_t_7;
+      goto __pyx_L7_bool_binop_done;
+    }
+    __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0);
+    __pyx_t_6 = __pyx_t_7;
+    __pyx_L7_bool_binop_done:;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")
+ */
+    if (__pyx_t_6) {
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":803
+ *         if ((child.byteorder == c'>' and little_endian) or
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
+ *             # One could encode it in the format string and have Cython
+ *             # complain instead, BUT: < and > in format strings also imply
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 803, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(1, 803, __pyx_L1_error)
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")
+ */
+    }
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":813
+ * 
+ *         # Output padding bytes
+ *         while offset[0] < new_offset:             # <<<<<<<<<<<<<<
+ *             f[0] = 120 # "x"; pad byte
+ *             f += 1
+ */
+    while (1) {
+      __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 813, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 813, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 813, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (!__pyx_t_6) break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":814
+ *         # Output padding bytes
+ *         while offset[0] < new_offset:
+ *             f[0] = 120 # "x"; pad byte             # <<<<<<<<<<<<<<
+ *             f += 1
+ *             offset[0] += 1
+ */
+      (__pyx_v_f[0]) = 0x78;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":815
+ *         while offset[0] < new_offset:
+ *             f[0] = 120 # "x"; pad byte
+ *             f += 1             # <<<<<<<<<<<<<<
+ *             offset[0] += 1
+ * 
+ */
+      __pyx_v_f = (__pyx_v_f + 1);
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":816
+ *             f[0] = 120 # "x"; pad byte
+ *             f += 1
+ *             offset[0] += 1             # <<<<<<<<<<<<<<
+ * 
+ *         offset[0] += child.itemsize
+ */
+      __pyx_t_8 = 0;
+      (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1);
+    }
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":818
+ *             offset[0] += 1
+ * 
+ *         offset[0] += child.itemsize             # <<<<<<<<<<<<<<
+ * 
+ *         if not PyDataType_HASFIELDS(child):
+ */
+    __pyx_t_8 = 0;
+    (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize);
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":820
+ *         offset[0] += child.itemsize
+ * 
+ *         if not PyDataType_HASFIELDS(child):             # <<<<<<<<<<<<<<
+ *             t = child.type_num
+ *             if end - f < 5:
+ */
+    __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0);
+    if (__pyx_t_6) {
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":821
+ * 
+ *         if not PyDataType_HASFIELDS(child):
+ *             t = child.type_num             # <<<<<<<<<<<<<<
+ *             if end - f < 5:
+ *                 raise RuntimeError(u"Format string allocated too short.")
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 821, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4);
+      __pyx_t_4 = 0;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":822
+ *         if not PyDataType_HASFIELDS(child):
+ *             t = child.type_num
+ *             if end - f < 5:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(u"Format string allocated too short.")
+ * 
+ */
+      __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0);
+      if (__pyx_t_6) {
+
+        /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":823
+ *             t = child.type_num
+ *             if end - f < 5:
+ *                 raise RuntimeError(u"Format string allocated too short.")             # <<<<<<<<<<<<<<
+ * 
+ *             # Until ticket #99 is fixed, use integers to avoid warnings
+ */
+        __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 823, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __PYX_ERR(1, 823, __pyx_L1_error)
+
+        /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":822
+ *         if not PyDataType_HASFIELDS(child):
+ *             t = child.type_num
+ *             if end - f < 5:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(u"Format string allocated too short.")
+ * 
+ */
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":826
+ * 
+ *             # Until ticket #99 is fixed, use integers to avoid warnings
+ *             if   t == NPY_BYTE:        f[0] =  98 #"b"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 826, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 826, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 826, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 98;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":827
+ *             # Until ticket #99 is fixed, use integers to avoid warnings
+ *             if   t == NPY_BYTE:        f[0] =  98 #"b"
+ *             elif t == NPY_UBYTE:       f[0] =  66 #"B"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 827, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 827, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 827, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 66;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":828
+ *             if   t == NPY_BYTE:        f[0] =  98 #"b"
+ *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"
+ *             elif t == NPY_INT:         f[0] = 105 #"i"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 828, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 828, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 828, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x68;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":829
+ *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_INT:         f[0] = 105 #"i"
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 829, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 829, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 829, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 72;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":830
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"
+ *             elif t == NPY_INT:         f[0] = 105 #"i"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 830, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 830, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 830, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x69;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":831
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"
+ *             elif t == NPY_INT:         f[0] = 105 #"i"
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 831, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 831, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 831, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 73;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":832
+ *             elif t == NPY_INT:         f[0] = 105 #"i"
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 832, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 832, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 832, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x6C;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":833
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 833, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 833, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 833, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 76;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":834
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 834, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 834, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 834, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x71;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":835
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 835, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 835, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 835, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 81;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":836
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 836, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 836, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 836, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x66;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":837
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 837, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 837, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 837, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x64;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":838
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 838, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 838, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 838, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x67;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":839
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf             # <<<<<<<<<<<<<<
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
+ *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 839, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 839, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 839, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 90;
+        (__pyx_v_f[1]) = 0x66;
+        __pyx_v_f = (__pyx_v_f + 1);
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":840
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd             # <<<<<<<<<<<<<<
+ *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
+ *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 840, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 840, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 840, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 90;
+        (__pyx_v_f[1]) = 0x64;
+        __pyx_v_f = (__pyx_v_f + 1);
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":841
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
+ *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg             # <<<<<<<<<<<<<<
+ *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
+ *             else:
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 841, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 841, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 841, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 90;
+        (__pyx_v_f[1]) = 0x67;
+        __pyx_v_f = (__pyx_v_f + 1);
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":842
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
+ *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
+ *             elif t == NPY_OBJECT:      f[0] = 79 #"O"             # <<<<<<<<<<<<<<
+ *             else:
+ *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 842, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 842, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 842, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 79;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":844
+ *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
+ *             else:
+ *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)             # <<<<<<<<<<<<<<
+ *             f += 1
+ *         else:
+ */
+      /*else*/ {
+        __pyx_t_3 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 844, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 844, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GIVEREF(__pyx_t_3);
+        PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
+        __pyx_t_3 = 0;
+        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 844, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __PYX_ERR(1, 844, __pyx_L1_error)
+      }
+      __pyx_L15:;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":845
+ *             else:
+ *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ *             f += 1             # <<<<<<<<<<<<<<
+ *         else:
+ *             # Cython ignores struct boundary information ("T{...}"),
+ */
+      __pyx_v_f = (__pyx_v_f + 1);
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":820
+ *         offset[0] += child.itemsize
+ * 
+ *         if not PyDataType_HASFIELDS(child):             # <<<<<<<<<<<<<<
+ *             t = child.type_num
+ *             if end - f < 5:
+ */
+      goto __pyx_L13;
+    }
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":849
+ *             # Cython ignores struct boundary information ("T{...}"),
+ *             # so don't output it
+ *             f = _util_dtypestring(child, f, end, offset)             # <<<<<<<<<<<<<<
+ *     return f
+ * 
+ */
+    /*else*/ {
+      __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == NULL)) __PYX_ERR(1, 849, __pyx_L1_error)
+      __pyx_v_f = __pyx_t_9;
+    }
+    __pyx_L13:;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":794
+ *     cdef tuple fields
+ * 
+ *     for childname in descr.names:             # <<<<<<<<<<<<<<
+ *         fields = descr.fields[childname]
+ *         child, new_offset = fields
+ */
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":850
+ *             # so don't output it
+ *             f = _util_dtypestring(child, f, end, offset)
+ *     return f             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = __pyx_v_f;
+  goto __pyx_L0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":785
+ *     return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
+ * 
+ * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:             # <<<<<<<<<<<<<<
+ *     # Recursive utility function used in __getbuffer__ to get format
+ *     # string. The new location in the format string is returned.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_child);
+  __Pyx_XDECREF(__pyx_v_fields);
+  __Pyx_XDECREF(__pyx_v_childname);
+  __Pyx_XDECREF(__pyx_v_new_offset);
+  __Pyx_XDECREF(__pyx_v_t);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":966
+ * 
+ * 
+ * cdef inline void set_array_base(ndarray arr, object base):             # <<<<<<<<<<<<<<
+ *      cdef PyObject* baseptr
+ *      if base is None:
+ */
+
+static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) {
+  PyObject *__pyx_v_baseptr;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  __Pyx_RefNannySetupContext("set_array_base", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":968
+ * cdef inline void set_array_base(ndarray arr, object base):
+ *      cdef PyObject* baseptr
+ *      if base is None:             # <<<<<<<<<<<<<<
+ *          baseptr = NULL
+ *      else:
+ */
+  __pyx_t_1 = (__pyx_v_base == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":969
+ *      cdef PyObject* baseptr
+ *      if base is None:
+ *          baseptr = NULL             # <<<<<<<<<<<<<<
+ *      else:
+ *          Py_INCREF(base) # important to do this before decref below!
+ */
+    __pyx_v_baseptr = NULL;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":968
+ * cdef inline void set_array_base(ndarray arr, object base):
+ *      cdef PyObject* baseptr
+ *      if base is None:             # <<<<<<<<<<<<<<
+ *          baseptr = NULL
+ *      else:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":971
+ *          baseptr = NULL
+ *      else:
+ *          Py_INCREF(base) # important to do this before decref below!             # <<<<<<<<<<<<<<
+ *          baseptr = <PyObject*>base
+ *      Py_XDECREF(arr.base)
+ */
+  /*else*/ {
+    Py_INCREF(__pyx_v_base);
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":972
+ *      else:
+ *          Py_INCREF(base) # important to do this before decref below!
+ *          baseptr = <PyObject*>base             # <<<<<<<<<<<<<<
+ *      Py_XDECREF(arr.base)
+ *      arr.base = baseptr
+ */
+    __pyx_v_baseptr = ((PyObject *)__pyx_v_base);
+  }
+  __pyx_L3:;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":973
+ *          Py_INCREF(base) # important to do this before decref below!
+ *          baseptr = <PyObject*>base
+ *      Py_XDECREF(arr.base)             # <<<<<<<<<<<<<<
+ *      arr.base = baseptr
+ * 
+ */
+  Py_XDECREF(__pyx_v_arr->base);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":974
+ *          baseptr = <PyObject*>base
+ *      Py_XDECREF(arr.base)
+ *      arr.base = baseptr             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object get_array_base(ndarray arr):
+ */
+  __pyx_v_arr->base = __pyx_v_baseptr;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":966
+ * 
+ * 
+ * cdef inline void set_array_base(ndarray arr, object base):             # <<<<<<<<<<<<<<
+ *      cdef PyObject* baseptr
+ *      if base is None:
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976
+ *      arr.base = baseptr
+ * 
+ * cdef inline object get_array_base(ndarray arr):             # <<<<<<<<<<<<<<
+ *     if arr.base is NULL:
+ *         return None
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("get_array_base", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":977
+ * 
+ * cdef inline object get_array_base(ndarray arr):
+ *     if arr.base is NULL:             # <<<<<<<<<<<<<<
+ *         return None
+ *     else:
+ */
+  __pyx_t_1 = ((__pyx_v_arr->base == NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":978
+ * cdef inline object get_array_base(ndarray arr):
+ *     if arr.base is NULL:
+ *         return None             # <<<<<<<<<<<<<<
+ *     else:
+ *         return <object>arr.base
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(Py_None);
+    __pyx_r = Py_None;
+    goto __pyx_L0;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":977
+ * 
+ * cdef inline object get_array_base(ndarray arr):
+ *     if arr.base is NULL:             # <<<<<<<<<<<<<<
+ *         return None
+ *     else:
+ */
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":980
+ *         return None
+ *     else:
+ *         return <object>arr.base             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  /*else*/ {
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(((PyObject *)__pyx_v_arr->base));
+    __pyx_r = ((PyObject *)__pyx_v_arr->base);
+    goto __pyx_L0;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976
+ *      arr.base = baseptr
+ * 
+ * cdef inline object get_array_base(ndarray arr):             # <<<<<<<<<<<<<<
+ *     if arr.base is NULL:
+ *         return None
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":985
+ * # Versions of the import_* functions which are more suitable for
+ * # Cython code.
+ * cdef inline int import_array() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_array()
+ */
+
+static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  __Pyx_RefNannySetupContext("import_array", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":986
+ * # Cython code.
+ * cdef inline int import_array() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_array()
+ *     except Exception:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":987
+ * cdef inline int import_array() except -1:
+ *     try:
+ *         _import_array()             # <<<<<<<<<<<<<<
+ *     except Exception:
+ *         raise ImportError("numpy.core.multiarray failed to import")
+ */
+      __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(1, 987, __pyx_L3_error)
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":986
+ * # Cython code.
+ * cdef inline int import_array() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_array()
+ *     except Exception:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L10_try_end;
+    __pyx_L3_error:;
+    __Pyx_PyThreadState_assign
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":988
+ *     try:
+ *         _import_array()
+ *     except Exception:             # <<<<<<<<<<<<<<
+ *         raise ImportError("numpy.core.multiarray failed to import")
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_4) {
+      __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 988, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":989
+ *         _import_array()
+ *     except Exception:
+ *         raise ImportError("numpy.core.multiarray failed to import")             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline int import_umath() except -1:
+ */
+      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 989, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_Raise(__pyx_t_8, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __PYX_ERR(1, 989, __pyx_L5_except_error)
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":986
+ * # Cython code.
+ * cdef inline int import_array() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_array()
+ *     except Exception:
+ */
+    __Pyx_PyThreadState_assign
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L10_try_end:;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":985
+ * # Versions of the import_* functions which are more suitable for
+ * # Cython code.
+ * cdef inline int import_array() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_array()
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":991
+ *         raise ImportError("numpy.core.multiarray failed to import")
+ * 
+ * cdef inline int import_umath() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_umath()
+ */
+
+static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  __Pyx_RefNannySetupContext("import_umath", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":992
+ * 
+ * cdef inline int import_umath() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":993
+ * cdef inline int import_umath() except -1:
+ *     try:
+ *         _import_umath()             # <<<<<<<<<<<<<<
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")
+ */
+      __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(1, 993, __pyx_L3_error)
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":992
+ * 
+ * cdef inline int import_umath() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L10_try_end;
+    __pyx_L3_error:;
+    __Pyx_PyThreadState_assign
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":994
+ *     try:
+ *         _import_umath()
+ *     except Exception:             # <<<<<<<<<<<<<<
+ *         raise ImportError("numpy.core.umath failed to import")
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_4) {
+      __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 994, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":995
+ *         _import_umath()
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline int import_ufunc() except -1:
+ */
+      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 995, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_Raise(__pyx_t_8, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __PYX_ERR(1, 995, __pyx_L5_except_error)
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":992
+ * 
+ * cdef inline int import_umath() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+    __Pyx_PyThreadState_assign
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L10_try_end:;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":991
+ *         raise ImportError("numpy.core.multiarray failed to import")
+ * 
+ * cdef inline int import_umath() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_umath()
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":997
+ *         raise ImportError("numpy.core.umath failed to import")
+ * 
+ * cdef inline int import_ufunc() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_umath()
+ */
+
+static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  __Pyx_RefNannySetupContext("import_ufunc", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":998
+ * 
+ * cdef inline int import_ufunc() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":999
+ * cdef inline int import_ufunc() except -1:
+ *     try:
+ *         _import_umath()             # <<<<<<<<<<<<<<
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")
+ */
+      __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(1, 999, __pyx_L3_error)
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":998
+ * 
+ * cdef inline int import_ufunc() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L10_try_end;
+    __pyx_L3_error:;
+    __Pyx_PyThreadState_assign
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":1000
+ *     try:
+ *         _import_umath()
+ *     except Exception:             # <<<<<<<<<<<<<<
+ *         raise ImportError("numpy.core.umath failed to import")
+ */
+    __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_4) {
+      __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1000, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":1001
+ *         _import_umath()
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")             # <<<<<<<<<<<<<<
+ */
+      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1001, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_Raise(__pyx_t_8, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __PYX_ERR(1, 1001, __pyx_L5_except_error)
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":998
+ * 
+ * cdef inline int import_ufunc() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+    __Pyx_PyThreadState_assign
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L10_try_end:;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":997
+ *         raise ImportError("numpy.core.umath failed to import")
+ * 
+ * cdef inline int import_ufunc() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_umath()
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyMethodDef __pyx_methods[] = {
+  {0, 0, 0, 0}
+};
+
+#if PY_MAJOR_VERSION >= 3
+static struct PyModuleDef __pyx_moduledef = {
+  #if PY_VERSION_HEX < 0x03020000
+    { PyObject_HEAD_INIT(NULL) NULL, 0, NULL },
+  #else
+    PyModuleDef_HEAD_INIT,
+  #endif
+    "cython_bbox",
+    0, /* m_doc */
+    -1, /* m_size */
+    __pyx_methods /* m_methods */,
+    NULL, /* m_reload */
+    NULL, /* m_traverse */
+    NULL, /* m_clear */
+    NULL /* m_free */
+};
+#endif
+
+static __Pyx_StringTabEntry __pyx_string_tab[] = {
+  {&__pyx_n_s_DTYPE, __pyx_k_DTYPE, sizeof(__pyx_k_DTYPE), 0, 0, 1, 1},
+  {&__pyx_n_s_FG_THRESH, __pyx_k_FG_THRESH, sizeof(__pyx_k_FG_THRESH), 0, 0, 1, 1},
+  {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0},
+  {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0},
+  {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1},
+  {&__pyx_n_s_K, __pyx_k_K, sizeof(__pyx_k_K), 0, 0, 1, 1},
+  {&__pyx_n_s_N, __pyx_k_N, sizeof(__pyx_k_N), 0, 0, 1, 1},
+  {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0},
+  {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1},
+  {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1},
+  {&__pyx_n_s_bbox_overlaps, __pyx_k_bbox_overlaps, sizeof(__pyx_k_bbox_overlaps), 0, 0, 1, 1},
+  {&__pyx_n_s_bbox_overlaps_float, __pyx_k_bbox_overlaps_float, sizeof(__pyx_k_bbox_overlaps_float), 0, 0, 1, 1},
+  {&__pyx_n_s_bbox_overlaps_ignore, __pyx_k_bbox_overlaps_ignore, sizeof(__pyx_k_bbox_overlaps_ignore), 0, 0, 1, 1},
+  {&__pyx_n_s_bbox_overlaps_self, __pyx_k_bbox_overlaps_self, sizeof(__pyx_k_bbox_overlaps_self), 0, 0, 1, 1},
+  {&__pyx_n_s_box_area, __pyx_k_box_area, sizeof(__pyx_k_box_area), 0, 0, 1, 1},
+  {&__pyx_n_s_boxes, __pyx_k_boxes, sizeof(__pyx_k_boxes), 0, 0, 1, 1},
+  {&__pyx_n_s_cython_bbox, __pyx_k_cython_bbox, sizeof(__pyx_k_cython_bbox), 0, 0, 1, 1},
+  {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1},
+  {&__pyx_n_s_float, __pyx_k_float, sizeof(__pyx_k_float), 0, 0, 1, 1},
+  {&__pyx_n_s_get_assignment_overlaps, __pyx_k_get_assignment_overlaps, sizeof(__pyx_k_get_assignment_overlaps), 0, 0, 1, 1},
+  {&__pyx_n_s_gt_assignment, __pyx_k_gt_assignment, sizeof(__pyx_k_gt_assignment), 0, 0, 1, 1},
+  {&__pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_k_home_yjr_PycharmProjects_Faster, sizeof(__pyx_k_home_yjr_PycharmProjects_Faster), 0, 0, 1, 0},
+  {&__pyx_n_s_ih, __pyx_k_ih, sizeof(__pyx_k_ih), 0, 0, 1, 1},
+  {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
+  {&__pyx_n_s_int, __pyx_k_int, sizeof(__pyx_k_int), 0, 0, 1, 1},
+  {&__pyx_n_s_iw, __pyx_k_iw, sizeof(__pyx_k_iw), 0, 0, 1, 1},
+  {&__pyx_n_s_k, __pyx_k_k, sizeof(__pyx_k_k), 0, 0, 1, 1},
+  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
+  {&__pyx_n_s_max_overlaps, __pyx_k_max_overlaps, sizeof(__pyx_k_max_overlaps), 0, 0, 1, 1},
+  {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1},
+  {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0},
+  {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0},
+  {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1},
+  {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1},
+  {&__pyx_kp_s_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 0, 1, 0},
+  {&__pyx_kp_s_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 0, 1, 0},
+  {&__pyx_n_s_overlap, __pyx_k_overlap, sizeof(__pyx_k_overlap), 0, 0, 1, 1},
+  {&__pyx_n_s_overlaps, __pyx_k_overlaps, sizeof(__pyx_k_overlaps), 0, 0, 1, 1},
+  {&__pyx_n_s_query_boxes, __pyx_k_query_boxes, sizeof(__pyx_k_query_boxes), 0, 0, 1, 1},
+  {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1},
+  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
+  {&__pyx_n_s_ua, __pyx_k_ua, sizeof(__pyx_k_ua), 0, 0, 1, 1},
+  {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0},
+  {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1},
+  {0, 0, 0, 0, 0, 0, 0}
+};
+static int __Pyx_InitCachedBuiltins(void) {
+  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 33, __pyx_L1_error)
+  __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 218, __pyx_L1_error)
+  __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 799, __pyx_L1_error)
+  __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 989, __pyx_L1_error)
+  return 0;
+  __pyx_L1_error:;
+  return -1;
+}
+
+static int __Pyx_InitCachedConstants(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":218
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")             # <<<<<<<<<<<<<<
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ */
+  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple_);
+  __Pyx_GIVEREF(__pyx_tuple_);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":222
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")             # <<<<<<<<<<<<<<
+ * 
+ *             info.buf = PyArray_DATA(self)
+ */
+  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__2);
+  __Pyx_GIVEREF(__pyx_tuple__2);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":259
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
+ *                 if   t == NPY_BYTE:        f = "b"
+ *                 elif t == NPY_UBYTE:       f = "B"
+ */
+  __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 259, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__3);
+  __Pyx_GIVEREF(__pyx_tuple__3);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":799
+ * 
+ *         if (end - f) - <int>(new_offset - offset[0]) < 15:
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")             # <<<<<<<<<<<<<<
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or
+ */
+  __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 799, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__4);
+  __Pyx_GIVEREF(__pyx_tuple__4);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":803
+ *         if ((child.byteorder == c'>' and little_endian) or
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
+ *             # One could encode it in the format string and have Cython
+ *             # complain instead, BUT: < and > in format strings also imply
+ */
+  __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 803, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__5);
+  __Pyx_GIVEREF(__pyx_tuple__5);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":823
+ *             t = child.type_num
+ *             if end - f < 5:
+ *                 raise RuntimeError(u"Format string allocated too short.")             # <<<<<<<<<<<<<<
+ * 
+ *             # Until ticket #99 is fixed, use integers to avoid warnings
+ */
+  __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 823, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__6);
+  __Pyx_GIVEREF(__pyx_tuple__6);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":989
+ *         _import_array()
+ *     except Exception:
+ *         raise ImportError("numpy.core.multiarray failed to import")             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline int import_umath() except -1:
+ */
+  __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 989, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__7);
+  __Pyx_GIVEREF(__pyx_tuple__7);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":995
+ *         _import_umath()
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline int import_ufunc() except -1:
+ */
+  __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 995, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__8);
+  __Pyx_GIVEREF(__pyx_tuple__8);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":1001
+ *         _import_umath()
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")             # <<<<<<<<<<<<<<
+ */
+  __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 1001, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__9);
+  __Pyx_GIVEREF(__pyx_tuple__9);
+
+  /* "bbox.pyx":15
+ * ctypedef np.float_t DTYPE_t
+ * 
+ * def bbox_overlaps_float(             # <<<<<<<<<<<<<<
+ *         np.ndarray[DTYPE_t, ndim=2] boxes,
+ *         np.ndarray[DTYPE_t, ndim=2] query_boxes):
+ */
+  __pyx_tuple__10 = PyTuple_Pack(11, __pyx_n_s_boxes, __pyx_n_s_query_boxes, __pyx_n_s_N, __pyx_n_s_K, __pyx_n_s_overlaps, __pyx_n_s_iw, __pyx_n_s_ih, __pyx_n_s_box_area, __pyx_n_s_ua, __pyx_n_s_k, __pyx_n_s_n); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 15, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__10);
+  __Pyx_GIVEREF(__pyx_tuple__10);
+  __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(2, 0, 11, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_n_s_bbox_overlaps_float, 15, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(0, 15, __pyx_L1_error)
+
+  /* "bbox.pyx":66
+ *     return overlaps
+ * 
+ * def bbox_overlaps(             # <<<<<<<<<<<<<<
+ *         np.ndarray[DTYPE_t, ndim=2] boxes,
+ *         np.ndarray[DTYPE_t, ndim=2] query_boxes):
+ */
+  __pyx_tuple__12 = PyTuple_Pack(11, __pyx_n_s_boxes, __pyx_n_s_query_boxes, __pyx_n_s_N, __pyx_n_s_K, __pyx_n_s_overlaps, __pyx_n_s_iw, __pyx_n_s_ih, __pyx_n_s_box_area, __pyx_n_s_ua, __pyx_n_s_k, __pyx_n_s_n); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 66, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__12);
+  __Pyx_GIVEREF(__pyx_tuple__12);
+  __pyx_codeobj__13 = (PyObject*)__Pyx_PyCode_New(2, 0, 11, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_n_s_bbox_overlaps, 66, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__13)) __PYX_ERR(0, 66, __pyx_L1_error)
+
+  /* "bbox.pyx":108
+ *     return overlaps
+ * 
+ * def bbox_overlaps_self(             # <<<<<<<<<<<<<<
+ *         np.ndarray[DTYPE_t, ndim=2] boxes,
+ *         np.ndarray[DTYPE_t, ndim=2] query_boxes):
+ */
+  __pyx_tuple__14 = PyTuple_Pack(11, __pyx_n_s_boxes, __pyx_n_s_query_boxes, __pyx_n_s_N, __pyx_n_s_K, __pyx_n_s_overlaps, __pyx_n_s_iw, __pyx_n_s_ih, __pyx_n_s_box_area, __pyx_n_s_ua, __pyx_n_s_k, __pyx_n_s_n); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 108, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__14);
+  __Pyx_GIVEREF(__pyx_tuple__14);
+  __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(2, 0, 11, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_n_s_bbox_overlaps_self, 108, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(0, 108, __pyx_L1_error)
+
+  /* "bbox.pyx":147
+ * 
+ * 
+ * def bbox_overlaps_ignore(             # <<<<<<<<<<<<<<
+ *         np.ndarray[DTYPE_t, ndim=2] boxes,
+ *         np.ndarray[DTYPE_t, ndim=2] query_boxes):
+ */
+  __pyx_tuple__16 = PyTuple_Pack(11, __pyx_n_s_boxes, __pyx_n_s_query_boxes, __pyx_n_s_N, __pyx_n_s_K, __pyx_n_s_overlaps, __pyx_n_s_iw, __pyx_n_s_ih, __pyx_n_s_box_area, __pyx_n_s_ua, __pyx_n_s_k, __pyx_n_s_n); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 147, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__16);
+  __Pyx_GIVEREF(__pyx_tuple__16);
+  __pyx_codeobj__17 = (PyObject*)__Pyx_PyCode_New(2, 0, 11, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_n_s_bbox_overlaps_ignore, 147, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(0, 147, __pyx_L1_error)
+
+  /* "bbox.pyx":194
+ * 
+ * 
+ * def get_assignment_overlaps(             # <<<<<<<<<<<<<<
+ *         np.ndarray[DTYPE_t, ndim=2] boxes,
+ *         np.ndarray[DTYPE_t, ndim=2] query_boxes,
+ */
+  __pyx_tuple__18 = PyTuple_Pack(14, __pyx_n_s_boxes, __pyx_n_s_query_boxes, __pyx_n_s_FG_THRESH, __pyx_n_s_N, __pyx_n_s_K, __pyx_n_s_gt_assignment, __pyx_n_s_max_overlaps, __pyx_n_s_iw, __pyx_n_s_ih, __pyx_n_s_box_area, __pyx_n_s_ua, __pyx_n_s_k, __pyx_n_s_n, __pyx_n_s_overlap); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 194, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__18);
+  __Pyx_GIVEREF(__pyx_tuple__18);
+  __pyx_codeobj__19 = (PyObject*)__Pyx_PyCode_New(3, 0, 14, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_n_s_get_assignment_overlaps, 194, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) __PYX_ERR(0, 194, __pyx_L1_error)
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+
+static int __Pyx_InitGlobals(void) {
+  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+  return 0;
+  __pyx_L1_error:;
+  return -1;
+}
+
+#if PY_MAJOR_VERSION < 3
+PyMODINIT_FUNC initcython_bbox(void); /*proto*/
+PyMODINIT_FUNC initcython_bbox(void)
+#else
+PyMODINIT_FUNC PyInit_cython_bbox(void); /*proto*/
+PyMODINIT_FUNC PyInit_cython_bbox(void)
+#endif
+{
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannyDeclarations
+  #if CYTHON_REFNANNY
+  __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
+  if (!__Pyx_RefNanny) {
+      PyErr_Clear();
+      __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny");
+      if (!__Pyx_RefNanny)
+          Py_FatalError("failed to import 'refnanny' module");
+  }
+  #endif
+  __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_cython_bbox(void)", 0);
+  if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #ifdef __Pyx_CyFunction_USED
+  if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_Generator_USED
+  if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_StopAsyncIteration_USED
+  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  /*--- Library function declarations ---*/
+  /*--- Threads initialization code ---*/
+  #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
+  #ifdef WITH_THREAD /* Python build with threading support? */
+  PyEval_InitThreads();
+  #endif
+  #endif
+  /*--- Module creation code ---*/
+  #if PY_MAJOR_VERSION < 3
+  __pyx_m = Py_InitModule4("cython_bbox", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
+  #else
+  __pyx_m = PyModule_Create(&__pyx_moduledef);
+  #endif
+  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
+  Py_INCREF(__pyx_d);
+  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #if CYTHON_COMPILING_IN_PYPY
+  Py_INCREF(__pyx_b);
+  #endif
+  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+  /*--- Initialize various global constants etc. ---*/
+  if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
+  if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  if (__pyx_module_is_main_cython_bbox) {
+    if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  }
+  #if PY_MAJOR_VERSION >= 3
+  {
+    PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
+    if (!PyDict_GetItemString(modules, "cython_bbox")) {
+      if (unlikely(PyDict_SetItemString(modules, "cython_bbox", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+    }
+  }
+  #endif
+  /*--- Builtin init code ---*/
+  if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  /*--- Constants init code ---*/
+  if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  /*--- Global init code ---*/
+  /*--- Variable export code ---*/
+  /*--- Function export code ---*/
+  /*--- Type init code ---*/
+  /*--- Type import code ---*/
+  __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "type", 
+  #if CYTHON_COMPILING_IN_PYPY
+  sizeof(PyTypeObject),
+  #else
+  sizeof(PyHeapTypeObject),
+  #endif
+  0); if (unlikely(!__pyx_ptype_7cpython_4type_type)) __PYX_ERR(2, 9, __pyx_L1_error)
+  __pyx_ptype_5numpy_dtype = __Pyx_ImportType("numpy", "dtype", sizeof(PyArray_Descr), 0); if (unlikely(!__pyx_ptype_5numpy_dtype)) __PYX_ERR(1, 155, __pyx_L1_error)
+  __pyx_ptype_5numpy_flatiter = __Pyx_ImportType("numpy", "flatiter", sizeof(PyArrayIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_flatiter)) __PYX_ERR(1, 168, __pyx_L1_error)
+  __pyx_ptype_5numpy_broadcast = __Pyx_ImportType("numpy", "broadcast", sizeof(PyArrayMultiIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_broadcast)) __PYX_ERR(1, 172, __pyx_L1_error)
+  __pyx_ptype_5numpy_ndarray = __Pyx_ImportType("numpy", "ndarray", sizeof(PyArrayObject), 0); if (unlikely(!__pyx_ptype_5numpy_ndarray)) __PYX_ERR(1, 181, __pyx_L1_error)
+  __pyx_ptype_5numpy_ufunc = __Pyx_ImportType("numpy", "ufunc", sizeof(PyUFuncObject), 0); if (unlikely(!__pyx_ptype_5numpy_ufunc)) __PYX_ERR(1, 861, __pyx_L1_error)
+  /*--- Variable import code ---*/
+  /*--- Function import code ---*/
+  /*--- Execution code ---*/
+  #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
+  if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+
+  /* "bbox.pyx":9
+ * 
+ * cimport cython
+ * import numpy as np             # <<<<<<<<<<<<<<
+ * cimport numpy as np
+ * 
+ */
+  __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 9, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "bbox.pyx":12
+ * cimport numpy as np
+ * 
+ * DTYPE = np.float             # <<<<<<<<<<<<<<
+ * ctypedef np.float_t DTYPE_t
+ * 
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 12, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_DTYPE, __pyx_t_2) < 0) __PYX_ERR(0, 12, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "bbox.pyx":15
+ * ctypedef np.float_t DTYPE_t
+ * 
+ * def bbox_overlaps_float(             # <<<<<<<<<<<<<<
+ *         np.ndarray[DTYPE_t, ndim=2] boxes,
+ *         np.ndarray[DTYPE_t, ndim=2] query_boxes):
+ */
+  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_11cython_bbox_1bbox_overlaps_float, NULL, __pyx_n_s_cython_bbox); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 15, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_bbox_overlaps_float, __pyx_t_2) < 0) __PYX_ERR(0, 15, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "bbox.pyx":66
+ *     return overlaps
+ * 
+ * def bbox_overlaps(             # <<<<<<<<<<<<<<
+ *         np.ndarray[DTYPE_t, ndim=2] boxes,
+ *         np.ndarray[DTYPE_t, ndim=2] query_boxes):
+ */
+  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_11cython_bbox_3bbox_overlaps, NULL, __pyx_n_s_cython_bbox); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_bbox_overlaps, __pyx_t_2) < 0) __PYX_ERR(0, 66, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "bbox.pyx":108
+ *     return overlaps
+ * 
+ * def bbox_overlaps_self(             # <<<<<<<<<<<<<<
+ *         np.ndarray[DTYPE_t, ndim=2] boxes,
+ *         np.ndarray[DTYPE_t, ndim=2] query_boxes):
+ */
+  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_11cython_bbox_5bbox_overlaps_self, NULL, __pyx_n_s_cython_bbox); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_bbox_overlaps_self, __pyx_t_2) < 0) __PYX_ERR(0, 108, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "bbox.pyx":147
+ * 
+ * 
+ * def bbox_overlaps_ignore(             # <<<<<<<<<<<<<<
+ *         np.ndarray[DTYPE_t, ndim=2] boxes,
+ *         np.ndarray[DTYPE_t, ndim=2] query_boxes):
+ */
+  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_11cython_bbox_7bbox_overlaps_ignore, NULL, __pyx_n_s_cython_bbox); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 147, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_bbox_overlaps_ignore, __pyx_t_2) < 0) __PYX_ERR(0, 147, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "bbox.pyx":194
+ * 
+ * 
+ * def get_assignment_overlaps(             # <<<<<<<<<<<<<<
+ *         np.ndarray[DTYPE_t, ndim=2] boxes,
+ *         np.ndarray[DTYPE_t, ndim=2] query_boxes,
+ */
+  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_11cython_bbox_9get_assignment_overlaps, NULL, __pyx_n_s_cython_bbox); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 194, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_assignment_overlaps, __pyx_t_2) < 0) __PYX_ERR(0, 194, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "bbox.pyx":1
+ * # --------------------------------------------------------             # <<<<<<<<<<<<<<
+ * # Fast R-CNN
+ * # Copyright (c) 2015 Microsoft
+ */
+  __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":997
+ *         raise ImportError("numpy.core.umath failed to import")
+ * 
+ * cdef inline int import_ufunc() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_umath()
+ */
+
+  /*--- Wrapped vars code ---*/
+
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  if (__pyx_m) {
+    if (__pyx_d) {
+      __Pyx_AddTraceback("init cython_bbox", __pyx_clineno, __pyx_lineno, __pyx_filename);
+    }
+    Py_DECREF(__pyx_m); __pyx_m = 0;
+  } else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_ImportError, "init cython_bbox");
+  }
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  #if PY_MAJOR_VERSION < 3
+  return;
+  #else
+  return __pyx_m;
+  #endif
+}
+
+/* --- Runtime support code --- */
+/* Refnanny */
+#if CYTHON_REFNANNY
+static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
+    PyObject *m = NULL, *p = NULL;
+    void *r = NULL;
+    m = PyImport_ImportModule((char *)modname);
+    if (!m) goto end;
+    p = PyObject_GetAttrString(m, (char *)"RefNannyAPI");
+    if (!p) goto end;
+    r = PyLong_AsVoidPtr(p);
+end:
+    Py_XDECREF(p);
+    Py_XDECREF(m);
+    return (__Pyx_RefNannyAPIStruct *)r;
+}
+#endif
+
+/* GetBuiltinName */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
+    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
+    if (unlikely(!result)) {
+        PyErr_Format(PyExc_NameError,
+#if PY_MAJOR_VERSION >= 3
+            "name '%U' is not defined", name);
+#else
+            "name '%.200s' is not defined", PyString_AS_STRING(name));
+#endif
+    }
+    return result;
+}
+
+/* RaiseArgTupleInvalid */
+static void __Pyx_RaiseArgtupleInvalid(
+    const char* func_name,
+    int exact,
+    Py_ssize_t num_min,
+    Py_ssize_t num_max,
+    Py_ssize_t num_found)
+{
+    Py_ssize_t num_expected;
+    const char *more_or_less;
+    if (num_found < num_min) {
+        num_expected = num_min;
+        more_or_less = "at least";
+    } else {
+        num_expected = num_max;
+        more_or_less = "at most";
+    }
+    if (exact) {
+        more_or_less = "exactly";
+    }
+    PyErr_Format(PyExc_TypeError,
+                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                 func_name, more_or_less, num_expected,
+                 (num_expected == 1) ? "" : "s", num_found);
+}
+
+/* RaiseDoubleKeywords */
+static void __Pyx_RaiseDoubleKeywordsError(
+    const char* func_name,
+    PyObject* kw_name)
+{
+    PyErr_Format(PyExc_TypeError,
+        #if PY_MAJOR_VERSION >= 3
+        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
+        #else
+        "%s() got multiple values for keyword argument '%s'", func_name,
+        PyString_AsString(kw_name));
+        #endif
+}
+
+/* ParseKeywords */
+static int __Pyx_ParseOptionalKeywords(
+    PyObject *kwds,
+    PyObject **argnames[],
+    PyObject *kwds2,
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    const char* function_name)
+{
+    PyObject *key = 0, *value = 0;
+    Py_ssize_t pos = 0;
+    PyObject*** name;
+    PyObject*** first_kw_arg = argnames + num_pos_args;
+    while (PyDict_Next(kwds, &pos, &key, &value)) {
+        name = first_kw_arg;
+        while (*name && (**name != key)) name++;
+        if (*name) {
+            values[name-argnames] = value;
+            continue;
+        }
+        name = first_kw_arg;
+        #if PY_MAJOR_VERSION < 3
+        if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) {
+            while (*name) {
+                if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
+                        && _PyString_Eq(**name, key)) {
+                    values[name-argnames] = value;
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    if ((**argname == key) || (
+                            (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))
+                             && _PyString_Eq(**argname, key))) {
+                        goto arg_passed_twice;
+                    }
+                    argname++;
+                }
+            }
+        } else
+        #endif
+        if (likely(PyUnicode_Check(key))) {
+            while (*name) {
+                int cmp = (**name == key) ? 0 :
+                #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+                    (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 :
+                #endif
+                    PyUnicode_Compare(**name, key);
+                if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                if (cmp == 0) {
+                    values[name-argnames] = value;
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    int cmp = (**argname == key) ? 0 :
+                    #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+                        (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 :
+                    #endif
+                        PyUnicode_Compare(**argname, key);
+                    if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                    if (cmp == 0) goto arg_passed_twice;
+                    argname++;
+                }
+            }
+        } else
+            goto invalid_keyword_type;
+        if (kwds2) {
+            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
+        } else {
+            goto invalid_keyword;
+        }
+    }
+    return 0;
+arg_passed_twice:
+    __Pyx_RaiseDoubleKeywordsError(function_name, key);
+    goto bad;
+invalid_keyword_type:
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() keywords must be strings", function_name);
+    goto bad;
+invalid_keyword:
+    PyErr_Format(PyExc_TypeError,
+    #if PY_MAJOR_VERSION < 3
+        "%.200s() got an unexpected keyword argument '%.200s'",
+        function_name, PyString_AsString(key));
+    #else
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    #endif
+bad:
+    return -1;
+}
+
+/* ArgTypeTest */
+static void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) {
+    PyErr_Format(PyExc_TypeError,
+        "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)",
+        name, type->tp_name, Py_TYPE(obj)->tp_name);
+}
+static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,
+    const char *name, int exact)
+{
+    if (unlikely(!type)) {
+        PyErr_SetString(PyExc_SystemError, "Missing type object");
+        return 0;
+    }
+    if (none_allowed && obj == Py_None) return 1;
+    else if (exact) {
+        if (likely(Py_TYPE(obj) == type)) return 1;
+        #if PY_MAJOR_VERSION == 2
+        else if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1;
+        #endif
+    }
+    else {
+        if (likely(PyObject_TypeCheck(obj, type))) return 1;
+    }
+    __Pyx_RaiseArgumentTypeInvalid(name, obj, type);
+    return 0;
+}
+
+/* BufferFormatCheck */
+static CYTHON_INLINE int __Pyx_IsLittleEndian(void) {
+  unsigned int n = 1;
+  return *(unsigned char*)(&n) != 0;
+}
+static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,
+                              __Pyx_BufFmt_StackElem* stack,
+                              __Pyx_TypeInfo* type) {
+  stack[0].field = &ctx->root;
+  stack[0].parent_offset = 0;
+  ctx->root.type = type;
+  ctx->root.name = "buffer dtype";
+  ctx->root.offset = 0;
+  ctx->head = stack;
+  ctx->head->field = &ctx->root;
+  ctx->fmt_offset = 0;
+  ctx->head->parent_offset = 0;
+  ctx->new_packmode = '@';
+  ctx->enc_packmode = '@';
+  ctx->new_count = 1;
+  ctx->enc_count = 0;
+  ctx->enc_type = 0;
+  ctx->is_complex = 0;
+  ctx->is_valid_array = 0;
+  ctx->struct_alignment = 0;
+  while (type->typegroup == 'S') {
+    ++ctx->head;
+    ctx->head->field = type->fields;
+    ctx->head->parent_offset = 0;
+    type = type->fields->type;
+  }
+}
+static int __Pyx_BufFmt_ParseNumber(const char** ts) {
+    int count;
+    const char* t = *ts;
+    if (*t < '0' || *t > '9') {
+      return -1;
+    } else {
+        count = *t++ - '0';
+        while (*t >= '0' && *t < '9') {
+            count *= 10;
+            count += *t++ - '0';
+        }
+    }
+    *ts = t;
+    return count;
+}
+static int __Pyx_BufFmt_ExpectNumber(const char **ts) {
+    int number = __Pyx_BufFmt_ParseNumber(ts);
+    if (number == -1)
+        PyErr_Format(PyExc_ValueError,\
+                     "Does not understand character buffer dtype format string ('%c')", **ts);
+    return number;
+}
+static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) {
+  PyErr_Format(PyExc_ValueError,
+               "Unexpected format string character: '%c'", ch);
+}
+static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) {
+  switch (ch) {
+    case 'c': return "'char'";
+    case 'b': return "'signed char'";
+    case 'B': return "'unsigned char'";
+    case 'h': return "'short'";
+    case 'H': return "'unsigned short'";
+    case 'i': return "'int'";
+    case 'I': return "'unsigned int'";
+    case 'l': return "'long'";
+    case 'L': return "'unsigned long'";
+    case 'q': return "'long long'";
+    case 'Q': return "'unsigned long long'";
+    case 'f': return (is_complex ? "'complex float'" : "'float'");
+    case 'd': return (is_complex ? "'complex double'" : "'double'");
+    case 'g': return (is_complex ? "'complex long double'" : "'long double'");
+    case 'T': return "a struct";
+    case 'O': return "Python object";
+    case 'P': return "a pointer";
+    case 's': case 'p': return "a string";
+    case 0: return "end";
+    default: return "unparseable format string";
+  }
+}
+static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) {
+  switch (ch) {
+    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
+    case 'h': case 'H': return 2;
+    case 'i': case 'I': case 'l': case 'L': return 4;
+    case 'q': case 'Q': return 8;
+    case 'f': return (is_complex ? 8 : 4);
+    case 'd': return (is_complex ? 16 : 8);
+    case 'g': {
+      PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g')..");
+      return 0;
+    }
+    case 'O': case 'P': return sizeof(void*);
+    default:
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+}
+static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) {
+  switch (ch) {
+    case 'c': case 'b': case 'B': case 's': case 'p': return 1;
+    case 'h': case 'H': return sizeof(short);
+    case 'i': case 'I': return sizeof(int);
+    case 'l': case 'L': return sizeof(long);
+    #ifdef HAVE_LONG_LONG
+    case 'q': case 'Q': return sizeof(PY_LONG_LONG);
+    #endif
+    case 'f': return sizeof(float) * (is_complex ? 2 : 1);
+    case 'd': return sizeof(double) * (is_complex ? 2 : 1);
+    case 'g': return sizeof(long double) * (is_complex ? 2 : 1);
+    case 'O': case 'P': return sizeof(void*);
+    default: {
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+  }
+}
+typedef struct { char c; short x; } __Pyx_st_short;
+typedef struct { char c; int x; } __Pyx_st_int;
+typedef struct { char c; long x; } __Pyx_st_long;
+typedef struct { char c; float x; } __Pyx_st_float;
+typedef struct { char c; double x; } __Pyx_st_double;
+typedef struct { char c; long double x; } __Pyx_st_longdouble;
+typedef struct { char c; void *x; } __Pyx_st_void_p;
+#ifdef HAVE_LONG_LONG
+typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong;
+#endif
+static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) {
+  switch (ch) {
+    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
+    case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short);
+    case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int);
+    case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long);
+#ifdef HAVE_LONG_LONG
+    case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG);
+#endif
+    case 'f': return sizeof(__Pyx_st_float) - sizeof(float);
+    case 'd': return sizeof(__Pyx_st_double) - sizeof(double);
+    case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double);
+    case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*);
+    default:
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+}
+/* These are for computing the padding at the end of the struct to align
+   on the first member of the struct. This will probably the same as above,
+   but we don't have any guarantees.
+ */
+typedef struct { short x; char c; } __Pyx_pad_short;
+typedef struct { int x; char c; } __Pyx_pad_int;
+typedef struct { long x; char c; } __Pyx_pad_long;
+typedef struct { float x; char c; } __Pyx_pad_float;
+typedef struct { double x; char c; } __Pyx_pad_double;
+typedef struct { long double x; char c; } __Pyx_pad_longdouble;
+typedef struct { void *x; char c; } __Pyx_pad_void_p;
+#ifdef HAVE_LONG_LONG
+typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong;
+#endif
+static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) {
+  switch (ch) {
+    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
+    case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short);
+    case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int);
+    case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long);
+#ifdef HAVE_LONG_LONG
+    case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG);
+#endif
+    case 'f': return sizeof(__Pyx_pad_float) - sizeof(float);
+    case 'd': return sizeof(__Pyx_pad_double) - sizeof(double);
+    case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double);
+    case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*);
+    default:
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+}
+static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) {
+  switch (ch) {
+    case 'c':
+        return 'H';
+    case 'b': case 'h': case 'i':
+    case 'l': case 'q': case 's': case 'p':
+        return 'I';
+    case 'B': case 'H': case 'I': case 'L': case 'Q':
+        return 'U';
+    case 'f': case 'd': case 'g':
+        return (is_complex ? 'C' : 'R');
+    case 'O':
+        return 'O';
+    case 'P':
+        return 'P';
+    default: {
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+  }
+}
+static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) {
+  if (ctx->head == NULL || ctx->head->field == &ctx->root) {
+    const char* expected;
+    const char* quote;
+    if (ctx->head == NULL) {
+      expected = "end";
+      quote = "";
+    } else {
+      expected = ctx->head->field->type->name;
+      quote = "'";
+    }
+    PyErr_Format(PyExc_ValueError,
+                 "Buffer dtype mismatch, expected %s%s%s but got %s",
+                 quote, expected, quote,
+                 __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex));
+  } else {
+    __Pyx_StructField* field = ctx->head->field;
+    __Pyx_StructField* parent = (ctx->head - 1)->field;
+    PyErr_Format(PyExc_ValueError,
+                 "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'",
+                 field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex),
+                 parent->type->name, field->name);
+  }
+}
+static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) {
+  char group;
+  size_t size, offset, arraysize = 1;
+  if (ctx->enc_type == 0) return 0;
+  if (ctx->head->field->type->arraysize[0]) {
+    int i, ndim = 0;
+    if (ctx->enc_type == 's' || ctx->enc_type == 'p') {
+        ctx->is_valid_array = ctx->head->field->type->ndim == 1;
+        ndim = 1;
+        if (ctx->enc_count != ctx->head->field->type->arraysize[0]) {
+            PyErr_Format(PyExc_ValueError,
+                         "Expected a dimension of size %zu, got %zu",
+                         ctx->head->field->type->arraysize[0], ctx->enc_count);
+            return -1;
+        }
+    }
+    if (!ctx->is_valid_array) {
+      PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d",
+                   ctx->head->field->type->ndim, ndim);
+      return -1;
+    }
+    for (i = 0; i < ctx->head->field->type->ndim; i++) {
+      arraysize *= ctx->head->field->type->arraysize[i];
+    }
+    ctx->is_valid_array = 0;
+    ctx->enc_count = 1;
+  }
+  group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex);
+  do {
+    __Pyx_StructField* field = ctx->head->field;
+    __Pyx_TypeInfo* type = field->type;
+    if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') {
+      size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex);
+    } else {
+      size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex);
+    }
+    if (ctx->enc_packmode == '@') {
+      size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex);
+      size_t align_mod_offset;
+      if (align_at == 0) return -1;
+      align_mod_offset = ctx->fmt_offset % align_at;
+      if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset;
+      if (ctx->struct_alignment == 0)
+          ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type,
+                                                                 ctx->is_complex);
+    }
+    if (type->size != size || type->typegroup != group) {
+      if (type->typegroup == 'C' && type->fields != NULL) {
+        size_t parent_offset = ctx->head->parent_offset + field->offset;
+        ++ctx->head;
+        ctx->head->field = type->fields;
+        ctx->head->parent_offset = parent_offset;
+        continue;
+      }
+      if ((type->typegroup == 'H' || group == 'H') && type->size == size) {
+      } else {
+          __Pyx_BufFmt_RaiseExpected(ctx);
+          return -1;
+      }
+    }
+    offset = ctx->head->parent_offset + field->offset;
+    if (ctx->fmt_offset != offset) {
+      PyErr_Format(PyExc_ValueError,
+                   "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected",
+                   (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset);
+      return -1;
+    }
+    ctx->fmt_offset += size;
+    if (arraysize)
+      ctx->fmt_offset += (arraysize - 1) * size;
+    --ctx->enc_count;
+    while (1) {
+      if (field == &ctx->root) {
+        ctx->head = NULL;
+        if (ctx->enc_count != 0) {
+          __Pyx_BufFmt_RaiseExpected(ctx);
+          return -1;
+        }
+        break;
+      }
+      ctx->head->field = ++field;
+      if (field->type == NULL) {
+        --ctx->head;
+        field = ctx->head->field;
+        continue;
+      } else if (field->type->typegroup == 'S') {
+        size_t parent_offset = ctx->head->parent_offset + field->offset;
+        if (field->type->fields->type == NULL) continue;
+        field = field->type->fields;
+        ++ctx->head;
+        ctx->head->field = field;
+        ctx->head->parent_offset = parent_offset;
+        break;
+      } else {
+        break;
+      }
+    }
+  } while (ctx->enc_count);
+  ctx->enc_type = 0;
+  ctx->is_complex = 0;
+  return 0;
+}
+static CYTHON_INLINE PyObject *
+__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp)
+{
+    const char *ts = *tsp;
+    int i = 0, number;
+    int ndim = ctx->head->field->type->ndim;
+;
+    ++ts;
+    if (ctx->new_count != 1) {
+        PyErr_SetString(PyExc_ValueError,
+                        "Cannot handle repeated arrays in format string");
+        return NULL;
+    }
+    if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+    while (*ts && *ts != ')') {
+        switch (*ts) {
+            case ' ': case '\f': case '\r': case '\n': case '\t': case '\v':  continue;
+            default:  break;
+        }
+        number = __Pyx_BufFmt_ExpectNumber(&ts);
+        if (number == -1) return NULL;
+        if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i])
+            return PyErr_Format(PyExc_ValueError,
+                        "Expected a dimension of size %zu, got %d",
+                        ctx->head->field->type->arraysize[i], number);
+        if (*ts != ',' && *ts != ')')
+            return PyErr_Format(PyExc_ValueError,
+                                "Expected a comma in format string, got '%c'", *ts);
+        if (*ts == ',') ts++;
+        i++;
+    }
+    if (i != ndim)
+        return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d",
+                            ctx->head->field->type->ndim, i);
+    if (!*ts) {
+        PyErr_SetString(PyExc_ValueError,
+                        "Unexpected end of format string, expected ')'");
+        return NULL;
+    }
+    ctx->is_valid_array = 1;
+    ctx->new_count = 1;
+    *tsp = ++ts;
+    return Py_None;
+}
+static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) {
+  int got_Z = 0;
+  while (1) {
+    switch(*ts) {
+      case 0:
+        if (ctx->enc_type != 0 && ctx->head == NULL) {
+          __Pyx_BufFmt_RaiseExpected(ctx);
+          return NULL;
+        }
+        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+        if (ctx->head != NULL) {
+          __Pyx_BufFmt_RaiseExpected(ctx);
+          return NULL;
+        }
+        return ts;
+      case ' ':
+      case '\r':
+      case '\n':
+        ++ts;
+        break;
+      case '<':
+        if (!__Pyx_IsLittleEndian()) {
+          PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler");
+          return NULL;
+        }
+        ctx->new_packmode = '=';
+        ++ts;
+        break;
+      case '>':
+      case '!':
+        if (__Pyx_IsLittleEndian()) {
+          PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler");
+          return NULL;
+        }
+        ctx->new_packmode = '=';
+        ++ts;
+        break;
+      case '=':
+      case '@':
+      case '^':
+        ctx->new_packmode = *ts++;
+        break;
+      case 'T':
+        {
+          const char* ts_after_sub;
+          size_t i, struct_count = ctx->new_count;
+          size_t struct_alignment = ctx->struct_alignment;
+          ctx->new_count = 1;
+          ++ts;
+          if (*ts != '{') {
+            PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'");
+            return NULL;
+          }
+          if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+          ctx->enc_type = 0;
+          ctx->enc_count = 0;
+          ctx->struct_alignment = 0;
+          ++ts;
+          ts_after_sub = ts;
+          for (i = 0; i != struct_count; ++i) {
+            ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts);
+            if (!ts_after_sub) return NULL;
+          }
+          ts = ts_after_sub;
+          if (struct_alignment) ctx->struct_alignment = struct_alignment;
+        }
+        break;
+      case '}':
+        {
+          size_t alignment = ctx->struct_alignment;
+          ++ts;
+          if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+          ctx->enc_type = 0;
+          if (alignment && ctx->fmt_offset % alignment) {
+            ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment);
+          }
+        }
+        return ts;
+      case 'x':
+        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+        ctx->fmt_offset += ctx->new_count;
+        ctx->new_count = 1;
+        ctx->enc_count = 0;
+        ctx->enc_type = 0;
+        ctx->enc_packmode = ctx->new_packmode;
+        ++ts;
+        break;
+      case 'Z':
+        got_Z = 1;
+        ++ts;
+        if (*ts != 'f' && *ts != 'd' && *ts != 'g') {
+          __Pyx_BufFmt_RaiseUnexpectedChar('Z');
+          return NULL;
+        }
+      case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I':
+      case 'l': case 'L': case 'q': case 'Q':
+      case 'f': case 'd': case 'g':
+      case 'O': case 'p':
+        if (ctx->enc_type == *ts && got_Z == ctx->is_complex &&
+            ctx->enc_packmode == ctx->new_packmode) {
+          ctx->enc_count += ctx->new_count;
+          ctx->new_count = 1;
+          got_Z = 0;
+          ++ts;
+          break;
+        }
+      case 's':
+        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+        ctx->enc_count = ctx->new_count;
+        ctx->enc_packmode = ctx->new_packmode;
+        ctx->enc_type = *ts;
+        ctx->is_complex = got_Z;
+        ++ts;
+        ctx->new_count = 1;
+        got_Z = 0;
+        break;
+      case ':':
+        ++ts;
+        while(*ts != ':') ++ts;
+        ++ts;
+        break;
+      case '(':
+        if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL;
+        break;
+      default:
+        {
+          int number = __Pyx_BufFmt_ExpectNumber(&ts);
+          if (number == -1) return NULL;
+          ctx->new_count = (size_t)number;
+        }
+    }
+  }
+}
+static CYTHON_INLINE void __Pyx_ZeroBuffer(Py_buffer* buf) {
+  buf->buf = NULL;
+  buf->obj = NULL;
+  buf->strides = __Pyx_zeros;
+  buf->shape = __Pyx_zeros;
+  buf->suboffsets = __Pyx_minusones;
+}
+static CYTHON_INLINE int __Pyx_GetBufferAndValidate(
+        Py_buffer* buf, PyObject* obj,  __Pyx_TypeInfo* dtype, int flags,
+        int nd, int cast, __Pyx_BufFmt_StackElem* stack)
+{
+  if (obj == Py_None || obj == NULL) {
+    __Pyx_ZeroBuffer(buf);
+    return 0;
+  }
+  buf->buf = NULL;
+  if (__Pyx_GetBuffer(obj, buf, flags) == -1) goto fail;
+  if (buf->ndim != nd) {
+    PyErr_Format(PyExc_ValueError,
+                 "Buffer has wrong number of dimensions (expected %d, got %d)",
+                 nd, buf->ndim);
+    goto fail;
+  }
+  if (!cast) {
+    __Pyx_BufFmt_Context ctx;
+    __Pyx_BufFmt_Init(&ctx, stack, dtype);
+    if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail;
+  }
+  if ((unsigned)buf->itemsize != dtype->size) {
+    PyErr_Format(PyExc_ValueError,
+      "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)",
+      buf->itemsize, (buf->itemsize > 1) ? "s" : "",
+      dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : "");
+    goto fail;
+  }
+  if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones;
+  return 0;
+fail:;
+  __Pyx_ZeroBuffer(buf);
+  return -1;
+}
+static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) {
+  if (info->buf == NULL) return;
+  if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL;
+  __Pyx_ReleaseBuffer(info);
+}
+
+/* GetModuleGlobalName */
+  static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) {
+    PyObject *result;
+#if !CYTHON_AVOID_BORROWED_REFS
+    result = PyDict_GetItem(__pyx_d, name);
+    if (likely(result)) {
+        Py_INCREF(result);
+    } else {
+#else
+    result = PyObject_GetItem(__pyx_d, name);
+    if (!result) {
+        PyErr_Clear();
+#endif
+        result = __Pyx_GetBuiltinName(name);
+    }
+    return result;
+}
+
+/* PyObjectCall */
+    #if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *result;
+    ternaryfunc call = func->ob_type->tp_call;
+    if (unlikely(!call))
+        return PyObject_Call(func, arg, kw);
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    result = (*call)(func, arg, kw);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
+#endif
+
+/* ExtTypeTest */
+    static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
+    if (unlikely(!type)) {
+        PyErr_SetString(PyExc_SystemError, "Missing type object");
+        return 0;
+    }
+    if (likely(PyObject_TypeCheck(obj, type)))
+        return 1;
+    PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s",
+                 Py_TYPE(obj)->tp_name, type->tp_name);
+    return 0;
+}
+
+/* BufferIndexError */
+    static void __Pyx_RaiseBufferIndexError(int axis) {
+  PyErr_Format(PyExc_IndexError,
+     "Out of bounds on buffer access (axis %d)", axis);
+}
+
+/* PyErrFetchRestore */
+    #if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->curexc_type;
+    tmp_value = tstate->curexc_value;
+    tmp_tb = tstate->curexc_traceback;
+    tstate->curexc_type = type;
+    tstate->curexc_value = value;
+    tstate->curexc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+}
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+    *type = tstate->curexc_type;
+    *value = tstate->curexc_value;
+    *tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+}
+#endif
+
+/* RaiseException */
+    #if PY_MAJOR_VERSION < 3
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
+                        CYTHON_UNUSED PyObject *cause) {
+    __Pyx_PyThreadState_declare
+    Py_XINCREF(type);
+    if (!value || value == Py_None)
+        value = NULL;
+    else
+        Py_INCREF(value);
+    if (!tb || tb == Py_None)
+        tb = NULL;
+    else {
+        Py_INCREF(tb);
+        if (!PyTraceBack_Check(tb)) {
+            PyErr_SetString(PyExc_TypeError,
+                "raise: arg 3 must be a traceback or None");
+            goto raise_error;
+        }
+    }
+    if (PyType_Check(type)) {
+#if CYTHON_COMPILING_IN_PYPY
+        if (!value) {
+            Py_INCREF(Py_None);
+            value = Py_None;
+        }
+#endif
+        PyErr_NormalizeException(&type, &value, &tb);
+    } else {
+        if (value) {
+            PyErr_SetString(PyExc_TypeError,
+                "instance exception may not have a separate value");
+            goto raise_error;
+        }
+        value = type;
+        type = (PyObject*) Py_TYPE(type);
+        Py_INCREF(type);
+        if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
+            PyErr_SetString(PyExc_TypeError,
+                "raise: exception class must be a subclass of BaseException");
+            goto raise_error;
+        }
+    }
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrRestore(type, value, tb);
+    return;
+raise_error:
+    Py_XDECREF(value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+    return;
+}
+#else
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
+    PyObject* owned_instance = NULL;
+    if (tb == Py_None) {
+        tb = 0;
+    } else if (tb && !PyTraceBack_Check(tb)) {
+        PyErr_SetString(PyExc_TypeError,
+            "raise: arg 3 must be a traceback or None");
+        goto bad;
+    }
+    if (value == Py_None)
+        value = 0;
+    if (PyExceptionInstance_Check(type)) {
+        if (value) {
+            PyErr_SetString(PyExc_TypeError,
+                "instance exception may not have a separate value");
+            goto bad;
+        }
+        value = type;
+        type = (PyObject*) Py_TYPE(value);
+    } else if (PyExceptionClass_Check(type)) {
+        PyObject *instance_class = NULL;
+        if (value && PyExceptionInstance_Check(value)) {
+            instance_class = (PyObject*) Py_TYPE(value);
+            if (instance_class != type) {
+                int is_subclass = PyObject_IsSubclass(instance_class, type);
+                if (!is_subclass) {
+                    instance_class = NULL;
+                } else if (unlikely(is_subclass == -1)) {
+                    goto bad;
+                } else {
+                    type = instance_class;
+                }
+            }
+        }
+        if (!instance_class) {
+            PyObject *args;
+            if (!value)
+                args = PyTuple_New(0);
+            else if (PyTuple_Check(value)) {
+                Py_INCREF(value);
+                args = value;
+            } else
+                args = PyTuple_Pack(1, value);
+            if (!args)
+                goto bad;
+            owned_instance = PyObject_Call(type, args, NULL);
+            Py_DECREF(args);
+            if (!owned_instance)
+                goto bad;
+            value = owned_instance;
+            if (!PyExceptionInstance_Check(value)) {
+                PyErr_Format(PyExc_TypeError,
+                             "calling %R should have returned an instance of "
+                             "BaseException, not %R",
+                             type, Py_TYPE(value));
+                goto bad;
+            }
+        }
+    } else {
+        PyErr_SetString(PyExc_TypeError,
+            "raise: exception class must be a subclass of BaseException");
+        goto bad;
+    }
+#if PY_VERSION_HEX >= 0x03030000
+    if (cause) {
+#else
+    if (cause && cause != Py_None) {
+#endif
+        PyObject *fixed_cause;
+        if (cause == Py_None) {
+            fixed_cause = NULL;
+        } else if (PyExceptionClass_Check(cause)) {
+            fixed_cause = PyObject_CallObject(cause, NULL);
+            if (fixed_cause == NULL)
+                goto bad;
+        } else if (PyExceptionInstance_Check(cause)) {
+            fixed_cause = cause;
+            Py_INCREF(fixed_cause);
+        } else {
+            PyErr_SetString(PyExc_TypeError,
+                            "exception causes must derive from "
+                            "BaseException");
+            goto bad;
+        }
+        PyException_SetCause(value, fixed_cause);
+    }
+    PyErr_SetObject(type, value);
+    if (tb) {
+#if CYTHON_COMPILING_IN_PYPY
+        PyObject *tmp_type, *tmp_value, *tmp_tb;
+        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
+        Py_INCREF(tb);
+        PyErr_Restore(tmp_type, tmp_value, tb);
+        Py_XDECREF(tmp_tb);
+#else
+        PyThreadState *tstate = PyThreadState_GET();
+        PyObject* tmp_tb = tstate->curexc_traceback;
+        if (tb != tmp_tb) {
+            Py_INCREF(tb);
+            tstate->curexc_traceback = tb;
+            Py_XDECREF(tmp_tb);
+        }
+#endif
+    }
+bad:
+    Py_XDECREF(owned_instance);
+    return;
+}
+#endif
+
+/* RaiseTooManyValuesToUnpack */
+      static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
+    PyErr_Format(PyExc_ValueError,
+                 "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected);
+}
+
+/* RaiseNeedMoreValuesToUnpack */
+      static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
+    PyErr_Format(PyExc_ValueError,
+                 "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack",
+                 index, (index == 1) ? "" : "s");
+}
+
+/* RaiseNoneIterError */
+      static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+}
+
+/* SaveResetException */
+      #if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+    *type = tstate->exc_type;
+    *value = tstate->exc_value;
+    *tb = tstate->exc_traceback;
+    Py_XINCREF(*type);
+    Py_XINCREF(*value);
+    Py_XINCREF(*tb);
+}
+static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    tstate->exc_type = type;
+    tstate->exc_value = value;
+    tstate->exc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+}
+#endif
+
+/* PyErrExceptionMatches */
+      #if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
+    PyObject *exc_type = tstate->curexc_type;
+    if (exc_type == err) return 1;
+    if (unlikely(!exc_type)) return 0;
+    return PyErr_GivenExceptionMatches(exc_type, err);
+}
+#endif
+
+/* GetException */
+      #if CYTHON_FAST_THREAD_STATE
+static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+#else
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) {
+#endif
+    PyObject *local_type, *local_value, *local_tb;
+#if CYTHON_FAST_THREAD_STATE
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    local_type = tstate->curexc_type;
+    local_value = tstate->curexc_value;
+    local_tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+#else
+    PyErr_Fetch(&local_type, &local_value, &local_tb);
+#endif
+    PyErr_NormalizeException(&local_type, &local_value, &local_tb);
+#if CYTHON_FAST_THREAD_STATE
+    if (unlikely(tstate->curexc_type))
+#else
+    if (unlikely(PyErr_Occurred()))
+#endif
+        goto bad;
+    #if PY_MAJOR_VERSION >= 3
+    if (local_tb) {
+        if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0))
+            goto bad;
+    }
+    #endif
+    Py_XINCREF(local_tb);
+    Py_XINCREF(local_type);
+    Py_XINCREF(local_value);
+    *type = local_type;
+    *value = local_value;
+    *tb = local_tb;
+#if CYTHON_FAST_THREAD_STATE
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    tstate->exc_type = local_type;
+    tstate->exc_value = local_value;
+    tstate->exc_traceback = local_tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#else
+    PyErr_SetExcInfo(local_type, local_value, local_tb);
+#endif
+    return 0;
+bad:
+    *type = 0;
+    *value = 0;
+    *tb = 0;
+    Py_XDECREF(local_type);
+    Py_XDECREF(local_value);
+    Py_XDECREF(local_tb);
+    return -1;
+}
+
+/* Import */
+        static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
+    PyObject *empty_list = 0;
+    PyObject *module = 0;
+    PyObject *global_dict = 0;
+    PyObject *empty_dict = 0;
+    PyObject *list;
+    #if PY_VERSION_HEX < 0x03030000
+    PyObject *py_import;
+    py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import);
+    if (!py_import)
+        goto bad;
+    #endif
+    if (from_list)
+        list = from_list;
+    else {
+        empty_list = PyList_New(0);
+        if (!empty_list)
+            goto bad;
+        list = empty_list;
+    }
+    global_dict = PyModule_GetDict(__pyx_m);
+    if (!global_dict)
+        goto bad;
+    empty_dict = PyDict_New();
+    if (!empty_dict)
+        goto bad;
+    {
+        #if PY_MAJOR_VERSION >= 3
+        if (level == -1) {
+            if (strchr(__Pyx_MODULE_NAME, '.')) {
+                #if PY_VERSION_HEX < 0x03030000
+                PyObject *py_level = PyInt_FromLong(1);
+                if (!py_level)
+                    goto bad;
+                module = PyObject_CallFunctionObjArgs(py_import,
+                    name, global_dict, empty_dict, list, py_level, NULL);
+                Py_DECREF(py_level);
+                #else
+                module = PyImport_ImportModuleLevelObject(
+                    name, global_dict, empty_dict, list, 1);
+                #endif
+                if (!module) {
+                    if (!PyErr_ExceptionMatches(PyExc_ImportError))
+                        goto bad;
+                    PyErr_Clear();
+                }
+            }
+            level = 0;
+        }
+        #endif
+        if (!module) {
+            #if PY_VERSION_HEX < 0x03030000
+            PyObject *py_level = PyInt_FromLong(level);
+            if (!py_level)
+                goto bad;
+            module = PyObject_CallFunctionObjArgs(py_import,
+                name, global_dict, empty_dict, list, py_level, NULL);
+            Py_DECREF(py_level);
+            #else
+            module = PyImport_ImportModuleLevelObject(
+                name, global_dict, empty_dict, list, level);
+            #endif
+        }
+    }
+bad:
+    #if PY_VERSION_HEX < 0x03030000
+    Py_XDECREF(py_import);
+    #endif
+    Py_XDECREF(empty_list);
+    Py_XDECREF(empty_dict);
+    return module;
+}
+
+/* CodeObjectCache */
+        static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
+    int start = 0, mid = 0, end = count - 1;
+    if (end >= 0 && code_line > entries[end].code_line) {
+        return count;
+    }
+    while (start < end) {
+        mid = start + (end - start) / 2;
+        if (code_line < entries[mid].code_line) {
+            end = mid;
+        } else if (code_line > entries[mid].code_line) {
+             start = mid + 1;
+        } else {
+            return mid;
+        }
+    }
+    if (code_line <= entries[mid].code_line) {
+        return mid;
+    } else {
+        return mid + 1;
+    }
+}
+static PyCodeObject *__pyx_find_code_object(int code_line) {
+    PyCodeObject* code_object;
+    int pos;
+    if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) {
+        return NULL;
+    }
+    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
+    if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) {
+        return NULL;
+    }
+    code_object = __pyx_code_cache.entries[pos].code_object;
+    Py_INCREF(code_object);
+    return code_object;
+}
+static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
+    int pos, i;
+    __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries;
+    if (unlikely(!code_line)) {
+        return;
+    }
+    if (unlikely(!entries)) {
+        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry));
+        if (likely(entries)) {
+            __pyx_code_cache.entries = entries;
+            __pyx_code_cache.max_count = 64;
+            __pyx_code_cache.count = 1;
+            entries[0].code_line = code_line;
+            entries[0].code_object = code_object;
+            Py_INCREF(code_object);
+        }
+        return;
+    }
+    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
+    if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) {
+        PyCodeObject* tmp = entries[pos].code_object;
+        entries[pos].code_object = code_object;
+        Py_DECREF(tmp);
+        return;
+    }
+    if (__pyx_code_cache.count == __pyx_code_cache.max_count) {
+        int new_max = __pyx_code_cache.max_count + 64;
+        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc(
+            __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry));
+        if (unlikely(!entries)) {
+            return;
+        }
+        __pyx_code_cache.entries = entries;
+        __pyx_code_cache.max_count = new_max;
+    }
+    for (i=__pyx_code_cache.count; i>pos; i--) {
+        entries[i] = entries[i-1];
+    }
+    entries[pos].code_line = code_line;
+    entries[pos].code_object = code_object;
+    __pyx_code_cache.count++;
+    Py_INCREF(code_object);
+}
+
+/* AddTraceback */
+        #include "compile.h"
+#include "frameobject.h"
+#include "traceback.h"
+static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
+            const char *funcname, int c_line,
+            int py_line, const char *filename) {
+    PyCodeObject *py_code = 0;
+    PyObject *py_srcfile = 0;
+    PyObject *py_funcname = 0;
+    #if PY_MAJOR_VERSION < 3
+    py_srcfile = PyString_FromString(filename);
+    #else
+    py_srcfile = PyUnicode_FromString(filename);
+    #endif
+    if (!py_srcfile) goto bad;
+    if (c_line) {
+        #if PY_MAJOR_VERSION < 3
+        py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
+        #else
+        py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
+        #endif
+    }
+    else {
+        #if PY_MAJOR_VERSION < 3
+        py_funcname = PyString_FromString(funcname);
+        #else
+        py_funcname = PyUnicode_FromString(funcname);
+        #endif
+    }
+    if (!py_funcname) goto bad;
+    py_code = __Pyx_PyCode_New(
+        0,
+        0,
+        0,
+        0,
+        0,
+        __pyx_empty_bytes, /*PyObject *code,*/
+        __pyx_empty_tuple, /*PyObject *consts,*/
+        __pyx_empty_tuple, /*PyObject *names,*/
+        __pyx_empty_tuple, /*PyObject *varnames,*/
+        __pyx_empty_tuple, /*PyObject *freevars,*/
+        __pyx_empty_tuple, /*PyObject *cellvars,*/
+        py_srcfile,   /*PyObject *filename,*/
+        py_funcname,  /*PyObject *name,*/
+        py_line,
+        __pyx_empty_bytes  /*PyObject *lnotab*/
+    );
+    Py_DECREF(py_srcfile);
+    Py_DECREF(py_funcname);
+    return py_code;
+bad:
+    Py_XDECREF(py_srcfile);
+    Py_XDECREF(py_funcname);
+    return NULL;
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyCodeObject *py_code = 0;
+    PyFrameObject *py_frame = 0;
+    py_code = __pyx_find_code_object(c_line ? c_line : py_line);
+    if (!py_code) {
+        py_code = __Pyx_CreateCodeObjectForTraceback(
+            funcname, c_line, py_line, filename);
+        if (!py_code) goto bad;
+        __pyx_insert_code_object(c_line ? c_line : py_line, py_code);
+    }
+    py_frame = PyFrame_New(
+        PyThreadState_GET(), /*PyThreadState *tstate,*/
+        py_code,             /*PyCodeObject *code,*/
+        __pyx_d,      /*PyObject *globals,*/
+        0                    /*PyObject *locals*/
+    );
+    if (!py_frame) goto bad;
+    __Pyx_PyFrame_SetLineNumber(py_frame, py_line);
+    PyTraceBack_Here(py_frame);
+bad:
+    Py_XDECREF(py_code);
+    Py_XDECREF(py_frame);
+}
+
+#if PY_MAJOR_VERSION < 3
+static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) {
+    if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags);
+        if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags);
+    PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name);
+    return -1;
+}
+static void __Pyx_ReleaseBuffer(Py_buffer *view) {
+    PyObject *obj = view->obj;
+    if (!obj) return;
+    if (PyObject_CheckBuffer(obj)) {
+        PyBuffer_Release(view);
+        return;
+    }
+        if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) { __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); return; }
+    Py_DECREF(obj);
+    view->obj = NULL;
+}
+#endif
+
+
+        /* CIntToPy */
+        static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value) {
+    const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0;
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(unsigned int) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(unsigned int) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(unsigned int) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(unsigned int),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntFromPyVerify */
+        #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
+    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0)
+#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\
+    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1)
+#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\
+    {\
+        func_type value = func_value;\
+        if (sizeof(target_type) < sizeof(func_type)) {\
+            if (unlikely(value != (func_type) (target_type) value)) {\
+                func_type zero = 0;\
+                if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\
+                    return (target_type) -1;\
+                if (is_unsigned && unlikely(value < zero))\
+                    goto raise_neg_overflow;\
+                else\
+                    goto raise_overflow;\
+            }\
+        }\
+        return (target_type) value;\
+    }
+
+/* Declarations */
+        #if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
+      return ::std::complex< float >(x, y);
+    }
+  #else
+    static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
+      return x + y*(__pyx_t_float_complex)_Complex_I;
+    }
+  #endif
+#else
+    static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
+      __pyx_t_float_complex z;
+      z.real = x;
+      z.imag = y;
+      return z;
+    }
+#endif
+
+/* Arithmetic */
+        #if CYTHON_CCOMPLEX
+#else
+    static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+       return (a.real == b.real) && (a.imag == b.imag);
+    }
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        __pyx_t_float_complex z;
+        z.real = a.real + b.real;
+        z.imag = a.imag + b.imag;
+        return z;
+    }
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        __pyx_t_float_complex z;
+        z.real = a.real - b.real;
+        z.imag = a.imag - b.imag;
+        return z;
+    }
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        __pyx_t_float_complex z;
+        z.real = a.real * b.real - a.imag * b.imag;
+        z.imag = a.real * b.imag + a.imag * b.real;
+        return z;
+    }
+    #if 1
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        if (b.imag == 0) {
+            return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real);
+        } else if (fabsf(b.real) >= fabsf(b.imag)) {
+            if (b.real == 0 && b.imag == 0) {
+                return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag);
+            } else {
+                float r = b.imag / b.real;
+                float s = 1.0 / (b.real + b.imag * r);
+                return __pyx_t_float_complex_from_parts(
+                    (a.real + a.imag * r) * s, (a.imag - a.real * r) * s);
+            }
+        } else {
+            float r = b.real / b.imag;
+            float s = 1.0 / (b.imag + b.real * r);
+            return __pyx_t_float_complex_from_parts(
+                (a.real * r + a.imag) * s, (a.imag * r - a.real) * s);
+        }
+    }
+    #else
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        if (b.imag == 0) {
+            return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real);
+        } else {
+            float denom = b.real * b.real + b.imag * b.imag;
+            return __pyx_t_float_complex_from_parts(
+                (a.real * b.real + a.imag * b.imag) / denom,
+                (a.imag * b.real - a.real * b.imag) / denom);
+        }
+    }
+    #endif
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) {
+        __pyx_t_float_complex z;
+        z.real = -a.real;
+        z.imag = -a.imag;
+        return z;
+    }
+    static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) {
+       return (a.real == 0) && (a.imag == 0);
+    }
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) {
+        __pyx_t_float_complex z;
+        z.real =  a.real;
+        z.imag = -a.imag;
+        return z;
+    }
+    #if 1
+        static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) {
+          #if !defined(HAVE_HYPOT) || defined(_MSC_VER)
+            return sqrtf(z.real*z.real + z.imag*z.imag);
+          #else
+            return hypotf(z.real, z.imag);
+          #endif
+        }
+        static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+            __pyx_t_float_complex z;
+            float r, lnr, theta, z_r, z_theta;
+            if (b.imag == 0 && b.real == (int)b.real) {
+                if (b.real < 0) {
+                    float denom = a.real * a.real + a.imag * a.imag;
+                    a.real = a.real / denom;
+                    a.imag = -a.imag / denom;
+                    b.real = -b.real;
+                }
+                switch ((int)b.real) {
+                    case 0:
+                        z.real = 1;
+                        z.imag = 0;
+                        return z;
+                    case 1:
+                        return a;
+                    case 2:
+                        z = __Pyx_c_prod_float(a, a);
+                        return __Pyx_c_prod_float(a, a);
+                    case 3:
+                        z = __Pyx_c_prod_float(a, a);
+                        return __Pyx_c_prod_float(z, a);
+                    case 4:
+                        z = __Pyx_c_prod_float(a, a);
+                        return __Pyx_c_prod_float(z, z);
+                }
+            }
+            if (a.imag == 0) {
+                if (a.real == 0) {
+                    return a;
+                } else if (b.imag == 0) {
+                    z.real = powf(a.real, b.real);
+                    z.imag = 0;
+                    return z;
+                } else if (a.real > 0) {
+                    r = a.real;
+                    theta = 0;
+                } else {
+                    r = -a.real;
+                    theta = atan2f(0, -1);
+                }
+            } else {
+                r = __Pyx_c_abs_float(a);
+                theta = atan2f(a.imag, a.real);
+            }
+            lnr = logf(r);
+            z_r = expf(lnr * b.real - theta * b.imag);
+            z_theta = theta * b.real + lnr * b.imag;
+            z.real = z_r * cosf(z_theta);
+            z.imag = z_r * sinf(z_theta);
+            return z;
+        }
+    #endif
+#endif
+
+/* Declarations */
+        #if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
+      return ::std::complex< double >(x, y);
+    }
+  #else
+    static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
+      return x + y*(__pyx_t_double_complex)_Complex_I;
+    }
+  #endif
+#else
+    static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
+      __pyx_t_double_complex z;
+      z.real = x;
+      z.imag = y;
+      return z;
+    }
+#endif
+
+/* Arithmetic */
+        #if CYTHON_CCOMPLEX
+#else
+    static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+       return (a.real == b.real) && (a.imag == b.imag);
+    }
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        __pyx_t_double_complex z;
+        z.real = a.real + b.real;
+        z.imag = a.imag + b.imag;
+        return z;
+    }
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        __pyx_t_double_complex z;
+        z.real = a.real - b.real;
+        z.imag = a.imag - b.imag;
+        return z;
+    }
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        __pyx_t_double_complex z;
+        z.real = a.real * b.real - a.imag * b.imag;
+        z.imag = a.real * b.imag + a.imag * b.real;
+        return z;
+    }
+    #if 1
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        if (b.imag == 0) {
+            return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real);
+        } else if (fabs(b.real) >= fabs(b.imag)) {
+            if (b.real == 0 && b.imag == 0) {
+                return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag);
+            } else {
+                double r = b.imag / b.real;
+                double s = 1.0 / (b.real + b.imag * r);
+                return __pyx_t_double_complex_from_parts(
+                    (a.real + a.imag * r) * s, (a.imag - a.real * r) * s);
+            }
+        } else {
+            double r = b.real / b.imag;
+            double s = 1.0 / (b.imag + b.real * r);
+            return __pyx_t_double_complex_from_parts(
+                (a.real * r + a.imag) * s, (a.imag * r - a.real) * s);
+        }
+    }
+    #else
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        if (b.imag == 0) {
+            return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real);
+        } else {
+            double denom = b.real * b.real + b.imag * b.imag;
+            return __pyx_t_double_complex_from_parts(
+                (a.real * b.real + a.imag * b.imag) / denom,
+                (a.imag * b.real - a.real * b.imag) / denom);
+        }
+    }
+    #endif
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) {
+        __pyx_t_double_complex z;
+        z.real = -a.real;
+        z.imag = -a.imag;
+        return z;
+    }
+    static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) {
+       return (a.real == 0) && (a.imag == 0);
+    }
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) {
+        __pyx_t_double_complex z;
+        z.real =  a.real;
+        z.imag = -a.imag;
+        return z;
+    }
+    #if 1
+        static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) {
+          #if !defined(HAVE_HYPOT) || defined(_MSC_VER)
+            return sqrt(z.real*z.real + z.imag*z.imag);
+          #else
+            return hypot(z.real, z.imag);
+          #endif
+        }
+        static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+            __pyx_t_double_complex z;
+            double r, lnr, theta, z_r, z_theta;
+            if (b.imag == 0 && b.real == (int)b.real) {
+                if (b.real < 0) {
+                    double denom = a.real * a.real + a.imag * a.imag;
+                    a.real = a.real / denom;
+                    a.imag = -a.imag / denom;
+                    b.real = -b.real;
+                }
+                switch ((int)b.real) {
+                    case 0:
+                        z.real = 1;
+                        z.imag = 0;
+                        return z;
+                    case 1:
+                        return a;
+                    case 2:
+                        z = __Pyx_c_prod_double(a, a);
+                        return __Pyx_c_prod_double(a, a);
+                    case 3:
+                        z = __Pyx_c_prod_double(a, a);
+                        return __Pyx_c_prod_double(z, a);
+                    case 4:
+                        z = __Pyx_c_prod_double(a, a);
+                        return __Pyx_c_prod_double(z, z);
+                }
+            }
+            if (a.imag == 0) {
+                if (a.real == 0) {
+                    return a;
+                } else if (b.imag == 0) {
+                    z.real = pow(a.real, b.real);
+                    z.imag = 0;
+                    return z;
+                } else if (a.real > 0) {
+                    r = a.real;
+                    theta = 0;
+                } else {
+                    r = -a.real;
+                    theta = atan2(0, -1);
+                }
+            } else {
+                r = __Pyx_c_abs_double(a);
+                theta = atan2(a.imag, a.real);
+            }
+            lnr = log(r);
+            z_r = exp(lnr * b.real - theta * b.imag);
+            z_theta = theta * b.real + lnr * b.imag;
+            z.real = z_r * cos(z_theta);
+            z.imag = z_r * sin(z_theta);
+            return z;
+        }
+    #endif
+#endif
+
+/* CIntToPy */
+        static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
+    const int neg_one = (int) -1, const_zero = (int) 0;
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(int) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(int) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(int) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(int),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntToPy */
+        static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) {
+    const enum NPY_TYPES neg_one = (enum NPY_TYPES) -1, const_zero = (enum NPY_TYPES) 0;
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(enum NPY_TYPES) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(enum NPY_TYPES) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntFromPy */
+        static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) {
+    const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0;
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(unsigned int) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(unsigned int, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (unsigned int) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (unsigned int) 0;
+                case  1: __PYX_VERIFY_RETURN_INT(unsigned int, digit, digits[0])
+                case 2:
+                    if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(unsigned int) >= 2 * PyLong_SHIFT) {
+                            return (unsigned int) (((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(unsigned int) >= 3 * PyLong_SHIFT) {
+                            return (unsigned int) (((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(unsigned int) >= 4 * PyLong_SHIFT) {
+                            return (unsigned int) (((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]));
+                        }
+                    }
+                    break;
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (unsigned int) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if (sizeof(unsigned int) <= sizeof(unsigned long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (unsigned int) 0;
+                case -1: __PYX_VERIFY_RETURN_INT(unsigned int, sdigit, (sdigit) (-(sdigit)digits[0]))
+                case  1: __PYX_VERIFY_RETURN_INT(unsigned int,  digit, +digits[0])
+                case -2:
+                    if (8 * sizeof(unsigned int) - 1 > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) {
+                            return (unsigned int) (((unsigned int)-1)*(((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
+                        }
+                    }
+                    break;
+                case 2:
+                    if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) {
+                            return (unsigned int) ((((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
+                        }
+                    }
+                    break;
+                case -3:
+                    if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) {
+                            return (unsigned int) (((unsigned int)-1)*(((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) {
+                            return (unsigned int) ((((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
+                        }
+                    }
+                    break;
+                case -4:
+                    if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) {
+                            return (unsigned int) (((unsigned int)-1)*(((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) {
+                            return (unsigned int) ((((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
+                        }
+                    }
+                    break;
+            }
+#endif
+            if (sizeof(unsigned int) <= sizeof(long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(unsigned int, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(unsigned int, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+            PyErr_SetString(PyExc_RuntimeError,
+                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+            unsigned int val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+ #endif
+            if (likely(v)) {
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                int ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                              bytes, sizeof(val),
+                                              is_little, !is_unsigned);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            return (unsigned int) -1;
+        }
+    } else {
+        unsigned int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (unsigned int) -1;
+        val = __Pyx_PyInt_As_unsigned_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to unsigned int");
+    return (unsigned int) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to unsigned int");
+    return (unsigned int) -1;
+}
+
+/* CIntFromPy */
+        static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
+    const int neg_one = (int) -1, const_zero = (int) 0;
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(int) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (int) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (int) 0;
+                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
+                case 2:
+                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
+                            return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
+                            return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
+                            return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                        }
+                    }
+                    break;
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (int) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if (sizeof(int) <= sizeof(unsigned long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (int) 0;
+                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
+                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
+                case -2:
+                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                            return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case 2:
+                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                            return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case -3:
+                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                            return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                            return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case -4:
+                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                            return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                            return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+            }
+#endif
+            if (sizeof(int) <= sizeof(long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+            PyErr_SetString(PyExc_RuntimeError,
+                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+            int val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+ #endif
+            if (likely(v)) {
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                int ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                              bytes, sizeof(val),
+                                              is_little, !is_unsigned);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            return (int) -1;
+        }
+    } else {
+        int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (int) -1;
+        val = __Pyx_PyInt_As_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to int");
+    return (int) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to int");
+    return (int) -1;
+}
+
+/* CIntToPy */
+        static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
+    const long neg_one = (long) -1, const_zero = (long) 0;
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(long) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(long) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(long) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(long),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntFromPy */
+        static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
+    const long neg_one = (long) -1, const_zero = (long) 0;
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(long) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (long) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (long) 0;
+                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
+                case 2:
+                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
+                            return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
+                            return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
+                            return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                        }
+                    }
+                    break;
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (long) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if (sizeof(long) <= sizeof(unsigned long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (long) 0;
+                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
+                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
+                case -2:
+                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                            return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case 2:
+                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                            return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case -3:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                            return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                            return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case -4:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                            return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                            return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+            }
+#endif
+            if (sizeof(long) <= sizeof(long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+            PyErr_SetString(PyExc_RuntimeError,
+                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+            long val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+ #endif
+            if (likely(v)) {
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                int ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                              bytes, sizeof(val),
+                                              is_little, !is_unsigned);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            return (long) -1;
+        }
+    } else {
+        long val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (long) -1;
+        val = __Pyx_PyInt_As_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to long");
+    return (long) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to long");
+    return (long) -1;
+}
+
+/* CheckBinaryVersion */
+        static int __Pyx_check_binary_version(void) {
+    char ctversion[4], rtversion[4];
+    PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
+    PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion());
+    if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) {
+        char message[200];
+        PyOS_snprintf(message, sizeof(message),
+                      "compiletime version %s of module '%.100s' "
+                      "does not match runtime version %s",
+                      ctversion, __Pyx_MODULE_NAME, rtversion);
+        return PyErr_WarnEx(NULL, message, 1);
+    }
+    return 0;
+}
+
+/* ModuleImport */
+        #ifndef __PYX_HAVE_RT_ImportModule
+#define __PYX_HAVE_RT_ImportModule
+static PyObject *__Pyx_ImportModule(const char *name) {
+    PyObject *py_name = 0;
+    PyObject *py_module = 0;
+    py_name = __Pyx_PyIdentifier_FromString(name);
+    if (!py_name)
+        goto bad;
+    py_module = PyImport_Import(py_name);
+    Py_DECREF(py_name);
+    return py_module;
+bad:
+    Py_XDECREF(py_name);
+    return 0;
+}
+#endif
+
+/* TypeImport */
+        #ifndef __PYX_HAVE_RT_ImportType
+#define __PYX_HAVE_RT_ImportType
+static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name,
+    size_t size, int strict)
+{
+    PyObject *py_module = 0;
+    PyObject *result = 0;
+    PyObject *py_name = 0;
+    char warning[200];
+    Py_ssize_t basicsize;
+#ifdef Py_LIMITED_API
+    PyObject *py_basicsize;
+#endif
+    py_module = __Pyx_ImportModule(module_name);
+    if (!py_module)
+        goto bad;
+    py_name = __Pyx_PyIdentifier_FromString(class_name);
+    if (!py_name)
+        goto bad;
+    result = PyObject_GetAttr(py_module, py_name);
+    Py_DECREF(py_name);
+    py_name = 0;
+    Py_DECREF(py_module);
+    py_module = 0;
+    if (!result)
+        goto bad;
+    if (!PyType_Check(result)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s.%.200s is not a type object",
+            module_name, class_name);
+        goto bad;
+    }
+#ifndef Py_LIMITED_API
+    basicsize = ((PyTypeObject *)result)->tp_basicsize;
+#else
+    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
+    if (!py_basicsize)
+        goto bad;
+    basicsize = PyLong_AsSsize_t(py_basicsize);
+    Py_DECREF(py_basicsize);
+    py_basicsize = 0;
+    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
+#endif
+    if (!strict && (size_t)basicsize > size) {
+        PyOS_snprintf(warning, sizeof(warning),
+            "%s.%s size changed, may indicate binary incompatibility. Expected %zd, got %zd",
+            module_name, class_name, basicsize, size);
+        if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
+    }
+    else if ((size_t)basicsize != size) {
+        PyErr_Format(PyExc_ValueError,
+            "%.200s.%.200s has the wrong size, try recompiling. Expected %zd, got %zd",
+            module_name, class_name, basicsize, size);
+        goto bad;
+    }
+    return (PyTypeObject *)result;
+bad:
+    Py_XDECREF(py_module);
+    Py_XDECREF(result);
+    return NULL;
+}
+#endif
+
+/* InitStrings */
+        static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
+    while (t->p) {
+        #if PY_MAJOR_VERSION < 3
+        if (t->is_unicode) {
+            *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
+        } else if (t->intern) {
+            *t->p = PyString_InternFromString(t->s);
+        } else {
+            *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
+        }
+        #else
+        if (t->is_unicode | t->is_str) {
+            if (t->intern) {
+                *t->p = PyUnicode_InternFromString(t->s);
+            } else if (t->encoding) {
+                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
+            } else {
+                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
+            }
+        } else {
+            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
+        }
+        #endif
+        if (!*t->p)
+            return -1;
+        ++t;
+    }
+    return 0;
+}
+
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
+}
+static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) {
+    Py_ssize_t ignore;
+    return __Pyx_PyObject_AsStringAndSize(o, &ignore);
+}
+static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
+    if (
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+            __Pyx_sys_getdefaultencoding_not_ascii &&
+#endif
+            PyUnicode_Check(o)) {
+#if PY_VERSION_HEX < 0x03030000
+        char* defenc_c;
+        PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL);
+        if (!defenc) return NULL;
+        defenc_c = PyBytes_AS_STRING(defenc);
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+        {
+            char* end = defenc_c + PyBytes_GET_SIZE(defenc);
+            char* c;
+            for (c = defenc_c; c < end; c++) {
+                if ((unsigned char) (*c) >= 128) {
+                    PyUnicode_AsASCIIString(o);
+                    return NULL;
+                }
+            }
+        }
+#endif
+        *length = PyBytes_GET_SIZE(defenc);
+        return defenc_c;
+#else
+        if (__Pyx_PyUnicode_READY(o) == -1) return NULL;
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+        if (PyUnicode_IS_ASCII(o)) {
+            *length = PyUnicode_GET_LENGTH(o);
+            return PyUnicode_AsUTF8(o);
+        } else {
+            PyUnicode_AsASCIIString(o);
+            return NULL;
+        }
+#else
+        return PyUnicode_AsUTF8AndSize(o, length);
+#endif
+#endif
+    } else
+#endif
+#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+    if (PyByteArray_Check(o)) {
+        *length = PyByteArray_GET_SIZE(o);
+        return PyByteArray_AS_STRING(o);
+    } else
+#endif
+    {
+        char* result;
+        int r = PyBytes_AsStringAndSize(o, &result, length);
+        if (unlikely(r < 0)) {
+            return NULL;
+        } else {
+            return result;
+        }
+    }
+}
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
+   int is_true = x == Py_True;
+   if (is_true | (x == Py_False) | (x == Py_None)) return is_true;
+   else return PyObject_IsTrue(x);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) {
+#if CYTHON_USE_TYPE_SLOTS
+  PyNumberMethods *m;
+#endif
+  const char *name = NULL;
+  PyObject *res = NULL;
+#if PY_MAJOR_VERSION < 3
+  if (PyInt_Check(x) || PyLong_Check(x))
+#else
+  if (PyLong_Check(x))
+#endif
+    return __Pyx_NewRef(x);
+#if CYTHON_USE_TYPE_SLOTS
+  m = Py_TYPE(x)->tp_as_number;
+  #if PY_MAJOR_VERSION < 3
+  if (m && m->nb_int) {
+    name = "int";
+    res = PyNumber_Int(x);
+  }
+  else if (m && m->nb_long) {
+    name = "long";
+    res = PyNumber_Long(x);
+  }
+  #else
+  if (m && m->nb_int) {
+    name = "int";
+    res = PyNumber_Long(x);
+  }
+  #endif
+#else
+  res = PyNumber_Int(x);
+#endif
+  if (res) {
+#if PY_MAJOR_VERSION < 3
+    if (!PyInt_Check(res) && !PyLong_Check(res)) {
+#else
+    if (!PyLong_Check(res)) {
+#endif
+      PyErr_Format(PyExc_TypeError,
+                   "__%.4s__ returned non-%.4s (type %.200s)",
+                   name, name, Py_TYPE(res)->tp_name);
+      Py_DECREF(res);
+      return NULL;
+    }
+  }
+  else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_TypeError,
+                    "an integer is required");
+  }
+  return res;
+}
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
+  Py_ssize_t ival;
+  PyObject *x;
+#if PY_MAJOR_VERSION < 3
+  if (likely(PyInt_CheckExact(b))) {
+    if (sizeof(Py_ssize_t) >= sizeof(long))
+        return PyInt_AS_LONG(b);
+    else
+        return PyInt_AsSsize_t(x);
+  }
+#endif
+  if (likely(PyLong_CheckExact(b))) {
+    #if CYTHON_USE_PYLONG_INTERNALS
+    const digit* digits = ((PyLongObject*)b)->ob_digit;
+    const Py_ssize_t size = Py_SIZE(b);
+    if (likely(__Pyx_sst_abs(size) <= 1)) {
+        ival = likely(size) ? digits[0] : 0;
+        if (size == -1) ival = -ival;
+        return ival;
+    } else {
+      switch (size) {
+         case 2:
+           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -2:
+           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case 3:
+           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -3:
+           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case 4:
+           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -4:
+           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+      }
+    }
+    #endif
+    return PyLong_AsSsize_t(b);
+  }
+  x = PyNumber_Index(b);
+  if (!x) return -1;
+  ival = PyInt_AsSsize_t(x);
+  Py_DECREF(x);
+  return ival;
+}
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
+    return PyInt_FromSize_t(ival);
+}
+
+
+#endif /* Py_PYTHON_H */
diff --git a/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/bbox.pyx b/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/bbox.pyx
new file mode 100755
index 0000000..5b82bdf
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/bbox.pyx
@@ -0,0 +1,249 @@
+# --------------------------------------------------------
+# Fast R-CNN
+# Copyright (c) 2015 Microsoft
+# Licensed under The MIT License [see LICENSE for details]
+# Written by Sergey Karayev
+# --------------------------------------------------------
+
+cimport cython
+import numpy as np
+cimport numpy as np
+
+DTYPE = np.float
+ctypedef np.float_t DTYPE_t
+
+def bbox_overlaps_float(
+        np.ndarray[DTYPE_t, ndim=2] boxes,
+        np.ndarray[DTYPE_t, ndim=2] query_boxes):
+    """
+    Parameters
+    ----------
+    boxes: (N, 4) ndarray of float
+    query_boxes: (K, 4) ndarray of float
+    Returns
+    -------
+    overlaps: (N, K) ndarray of overlap between boxes and query_boxes
+    """
+    cdef unsigned int N = boxes.shape[0]
+    cdef unsigned int K = query_boxes.shape[0]
+    cdef np.ndarray[DTYPE_t, ndim=2] overlaps = np.zeros((N, K), dtype=DTYPE)
+    cdef DTYPE_t iw, ih, box_area
+    cdef DTYPE_t ua
+    cdef unsigned int k, n
+    for k in range(K):
+        box_area = (
+            (query_boxes[k, 2] - query_boxes[k, 0]) *
+            (query_boxes[k, 3] - query_boxes[k, 1])
+        )
+        for n in range(N):
+            iw = (
+                min(boxes[n, 2], query_boxes[k, 2]) -
+                max(boxes[n, 0], query_boxes[k, 0])
+            )
+            if iw > 0:
+                ih = (
+                    min(boxes[n, 3], query_boxes[k, 3]) -
+                    max(boxes[n, 1], query_boxes[k, 1])
+                )
+                if ih > 0:
+                    ua = float(
+                        (boxes[n, 2] - boxes[n, 0]) *
+                        (boxes[n, 3] - boxes[n, 1]) +
+                        box_area - iw * ih
+                    )
+                    # if query_boxes[k, 4] == -1:
+                    #     ua = float((boxes[n, 2] - boxes[n, 0])
+                    #               *(boxes[n, 3] - boxes[n, 1]))
+                    # else:
+                    #     ua = float(
+                    #         (boxes[n, 2] - boxes[n, 0]) *
+                    #         (boxes[n, 3] - boxes[n, 1]) +
+                    #         box_area - iw * ih
+                    #     )
+                    overlaps[n, k] = iw * ih / ua
+    return overlaps
+
+def bbox_overlaps(
+        np.ndarray[DTYPE_t, ndim=2] boxes,
+        np.ndarray[DTYPE_t, ndim=2] query_boxes):
+    """
+    Parameters
+    ----------
+    boxes: (N, 4) ndarray of float
+    query_boxes: (K, 4) ndarray of float
+    Returns
+    -------
+    overlaps: (N, K) ndarray of overlap between boxes and query_boxes
+    """
+    cdef unsigned int N = boxes.shape[0]
+    cdef unsigned int K = query_boxes.shape[0]
+    cdef np.ndarray[DTYPE_t, ndim=2] overlaps = np.zeros((N, K), dtype=DTYPE)
+    cdef DTYPE_t iw, ih, box_area
+    cdef DTYPE_t ua
+    cdef unsigned int k, n
+    for k in range(K):
+        box_area = (
+            (query_boxes[k, 2] - query_boxes[k, 0] + 1) *
+            (query_boxes[k, 3] - query_boxes[k, 1] + 1)
+        )
+        for n in range(N):
+            iw = (
+                min(boxes[n, 2], query_boxes[k, 2]) -
+                max(boxes[n, 0], query_boxes[k, 0]) + 1
+            )
+            if iw > 0:
+                ih = (
+                    min(boxes[n, 3], query_boxes[k, 3]) -
+                    max(boxes[n, 1], query_boxes[k, 1]) + 1
+                )
+                if ih > 0:
+                    ua = float(
+                        (boxes[n, 2] - boxes[n, 0] + 1) *
+                        (boxes[n, 3] - boxes[n, 1] + 1) +
+                        box_area - iw * ih
+                    )
+                    overlaps[n, k] = iw * ih / ua
+    return overlaps
+
+def bbox_overlaps_self(
+        np.ndarray[DTYPE_t, ndim=2] boxes,
+        np.ndarray[DTYPE_t, ndim=2] query_boxes):
+    """
+    Parameters
+    ----------
+    boxes: (N, 4) ndarray of float
+    query_boxes: (K, 4) ndarray of float
+    Returns
+    -------
+    overlaps: (N, K) ndarray of overlap between boxes and query_boxes
+    """
+    cdef unsigned int N = boxes.shape[0]
+    cdef unsigned int K = query_boxes.shape[0]
+    cdef np.ndarray[DTYPE_t, ndim=2] overlaps = np.zeros((N, K), dtype=DTYPE)
+    cdef DTYPE_t iw, ih, box_area
+    cdef DTYPE_t ua
+    cdef unsigned int k, n
+    for k in range(K):
+        box_area = (
+            (query_boxes[k, 2] - query_boxes[k, 0] + 1) *
+            (query_boxes[k, 3] - query_boxes[k, 1] + 1)
+        )
+        for n in range(N):
+            iw = (
+                min(boxes[n, 2], query_boxes[k, 2]) -
+                max(boxes[n, 0], query_boxes[k, 0]) + 1
+            )
+            if iw > 0:
+                ih = (
+                    min(boxes[n, 3], query_boxes[k, 3]) -
+                    max(boxes[n, 1], query_boxes[k, 1]) + 1
+                )
+                if ih > 0:
+                    ua = float(box_area)
+                    overlaps[n, k] = iw * ih / ua
+    return overlaps
+
+
+def bbox_overlaps_ignore(
+        np.ndarray[DTYPE_t, ndim=2] boxes,
+        np.ndarray[DTYPE_t, ndim=2] query_boxes):
+    """
+    Parameters
+    ----------
+    boxes: (N, 4) ndarray of float
+    query_boxes: (K, 4) ndarray of float
+    Returns
+    -------
+    overlaps: (N, K) ndarray of overlap between boxes and query_boxes
+    """
+    cdef unsigned int N = boxes.shape[0]
+    cdef unsigned int K = query_boxes.shape[0]
+    cdef np.ndarray[DTYPE_t, ndim=2] overlaps = np.zeros((N, K), dtype=DTYPE)
+    cdef DTYPE_t iw, ih, box_area
+    cdef DTYPE_t ua
+    cdef unsigned int k, n
+    for k in range(K):
+        box_area = (
+            (query_boxes[k, 2] - query_boxes[k, 0] + 1) *
+            (query_boxes[k, 3] - query_boxes[k, 1] + 1)
+        )
+        for n in range(N):
+            iw = (
+                min(boxes[n, 2], query_boxes[k, 2]) -
+                max(boxes[n, 0], query_boxes[k, 0]) + 1
+            )
+            if iw > 0:
+                ih = (
+                    min(boxes[n, 3], query_boxes[k, 3]) -
+                    max(boxes[n, 1], query_boxes[k, 1]) + 1
+                )
+                if ih > 0:
+                    if query_boxes[k, 4] == -1:
+                        ua = float((boxes[n, 2] - boxes[n, 0] + 1)
+                                  *(boxes[n, 3] - boxes[n, 1] + 1))
+                    else:
+                        ua = float(
+                            (boxes[n, 2] - boxes[n, 0] + 1) *
+                            (boxes[n, 3] - boxes[n, 1] + 1) +
+                            box_area - iw * ih
+                        )
+                    overlaps[n, k] = iw * ih / ua
+    return overlaps
+
+
+def get_assignment_overlaps(
+        np.ndarray[DTYPE_t, ndim=2] boxes,
+        np.ndarray[DTYPE_t, ndim=2] query_boxes,
+        DTYPE_t FG_THRESH):
+    """ Used for proposal_target_layer_ignore
+    Parameters
+    ----------
+    boxes: (N, 4) ndarray of float
+    query_boxes: (K, 4) ndarray of float
+    Returns
+    -------
+    overlaps: (N, K) ndarray of overlap between boxes and query_boxes
+    """
+    cdef unsigned int N = boxes.shape[0]
+    cdef unsigned int K = query_boxes.shape[0]
+    cdef np.ndarray[long, ndim=1] gt_assignment = np.zeros((N,), dtype=np.int)
+    cdef np.ndarray[DTYPE_t, ndim=1] max_overlaps = np.zeros((N,), dtype=DTYPE) 
+    cdef DTYPE_t iw, ih, box_area
+    cdef DTYPE_t ua
+    cdef unsigned int k, n
+    for k in range(K):
+        box_area = (
+            (query_boxes[k, 2] - query_boxes[k, 0] + 1) *
+            (query_boxes[k, 3] - query_boxes[k, 1] + 1)
+        )
+        for n in range(N):
+            iw = (
+                min(boxes[n, 2], query_boxes[k, 2]) -
+                max(boxes[n, 0], query_boxes[k, 0]) + 1
+            )
+            if iw > 0:
+                ih = (
+                    min(boxes[n, 3], query_boxes[k, 3]) -
+                    max(boxes[n, 1], query_boxes[k, 1]) + 1
+                )
+                if ih > 0:
+                    if query_boxes[k, 4] == -1:
+                        ua = float((boxes[n, 2] - boxes[n, 0] + 1)
+                                  *(boxes[n, 3] - boxes[n, 1] + 1))
+                        overlap = iw * ih / ua
+                        if overlap > max_overlaps[n]:
+                            if query_boxes[gt_assignment[n], 4] == -1 or max_overlaps[n] < FG_THRESH:
+                                max_overlaps[n] = overlap
+                                gt_assignment[n] = k
+                    else:
+                        ua = float(
+                            (boxes[n, 2] - boxes[n, 0] + 1) *
+                            (boxes[n, 3] - boxes[n, 1] + 1) +
+                            box_area - iw * ih
+                        )
+                        overlap = iw * ih / ua
+                        if overlap > max_overlaps[n]:
+                            max_overlaps[n] = overlap
+                            gt_assignment[n] = k
+                    #overlaps[n, k] = overlap
+    return gt_assignment, max_overlaps
diff --git a/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/build/temp.linux-x86_64-2.7/bbox.o b/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/build/temp.linux-x86_64-2.7/bbox.o
new file mode 100755
index 0000000..e6dc6a2
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/build/temp.linux-x86_64-2.7/bbox.o differ
diff --git a/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/build/temp.linux-x86_64-2.7/nms.o b/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/build/temp.linux-x86_64-2.7/nms.o
new file mode 100755
index 0000000..d381b2e
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/build/temp.linux-x86_64-2.7/nms.o differ
diff --git a/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/cython_bbox.so b/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/cython_bbox.so
new file mode 100755
index 0000000..055b6d7
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/cython_bbox.so differ
diff --git a/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/cython_nms.so b/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/cython_nms.so
new file mode 100755
index 0000000..90e0a20
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/cython_nms.so differ
diff --git a/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/nms.c b/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/nms.c
new file mode 100755
index 0000000..54934ea
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/nms.c
@@ -0,0 +1,9561 @@
+/* Generated by Cython 0.25.2 */
+
+#define PY_SSIZE_T_CLEAN
+#include "Python.h"
+#ifndef Py_PYTHON_H
+    #error Python headers needed to compile C extensions, please install development version of Python.
+#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000)
+    #error Cython requires Python 2.6+ or Python 3.2+.
+#else
+#define CYTHON_ABI "0_25_2"
+#include <stddef.h>
+#ifndef offsetof
+  #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
+#endif
+#if !defined(WIN32) && !defined(MS_WINDOWS)
+  #ifndef __stdcall
+    #define __stdcall
+  #endif
+  #ifndef __cdecl
+    #define __cdecl
+  #endif
+  #ifndef __fastcall
+    #define __fastcall
+  #endif
+#endif
+#ifndef DL_IMPORT
+  #define DL_IMPORT(t) t
+#endif
+#ifndef DL_EXPORT
+  #define DL_EXPORT(t) t
+#endif
+#ifndef HAVE_LONG_LONG
+  #if PY_VERSION_HEX >= 0x03030000 || (PY_MAJOR_VERSION == 2 && PY_VERSION_HEX >= 0x02070000)
+    #define HAVE_LONG_LONG
+  #endif
+#endif
+#ifndef PY_LONG_LONG
+  #define PY_LONG_LONG LONG_LONG
+#endif
+#ifndef Py_HUGE_VAL
+  #define Py_HUGE_VAL HUGE_VAL
+#endif
+#ifdef PYPY_VERSION
+  #define CYTHON_COMPILING_IN_PYPY 1
+  #define CYTHON_COMPILING_IN_PYSTON 0
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_ASYNC_SLOTS
+  #define CYTHON_USE_ASYNC_SLOTS 0
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #undef CYTHON_AVOID_BORROWED_REFS
+  #define CYTHON_AVOID_BORROWED_REFS 1
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+#elif defined(PYSTON_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_PYSTON 1
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #ifndef CYTHON_USE_TYPE_SLOTS
+    #define CYTHON_USE_TYPE_SLOTS 1
+  #endif
+  #undef CYTHON_USE_ASYNC_SLOTS
+  #define CYTHON_USE_ASYNC_SLOTS 0
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #ifndef CYTHON_USE_UNICODE_INTERNALS
+    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #endif
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #ifndef CYTHON_AVOID_BORROWED_REFS
+    #define CYTHON_AVOID_BORROWED_REFS 0
+  #endif
+  #ifndef CYTHON_ASSUME_SAFE_MACROS
+    #define CYTHON_ASSUME_SAFE_MACROS 1
+  #endif
+  #ifndef CYTHON_UNPACK_METHODS
+    #define CYTHON_UNPACK_METHODS 1
+  #endif
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+#else
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_PYSTON 0
+  #define CYTHON_COMPILING_IN_CPYTHON 1
+  #ifndef CYTHON_USE_TYPE_SLOTS
+    #define CYTHON_USE_TYPE_SLOTS 1
+  #endif
+  #if PY_MAJOR_VERSION < 3
+    #undef CYTHON_USE_ASYNC_SLOTS
+    #define CYTHON_USE_ASYNC_SLOTS 0
+  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+    #define CYTHON_USE_ASYNC_SLOTS 1
+  #endif
+  #if PY_VERSION_HEX < 0x02070000
+    #undef CYTHON_USE_PYLONG_INTERNALS
+    #define CYTHON_USE_PYLONG_INTERNALS 0
+  #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
+    #define CYTHON_USE_PYLONG_INTERNALS 1
+  #endif
+  #ifndef CYTHON_USE_PYLIST_INTERNALS
+    #define CYTHON_USE_PYLIST_INTERNALS 1
+  #endif
+  #ifndef CYTHON_USE_UNICODE_INTERNALS
+    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #endif
+  #if PY_VERSION_HEX < 0x030300F0
+    #undef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
+  #elif !defined(CYTHON_USE_UNICODE_WRITER)
+    #define CYTHON_USE_UNICODE_WRITER 1
+  #endif
+  #ifndef CYTHON_AVOID_BORROWED_REFS
+    #define CYTHON_AVOID_BORROWED_REFS 0
+  #endif
+  #ifndef CYTHON_ASSUME_SAFE_MACROS
+    #define CYTHON_ASSUME_SAFE_MACROS 1
+  #endif
+  #ifndef CYTHON_UNPACK_METHODS
+    #define CYTHON_UNPACK_METHODS 1
+  #endif
+  #ifndef CYTHON_FAST_THREAD_STATE
+    #define CYTHON_FAST_THREAD_STATE 1
+  #endif
+  #ifndef CYTHON_FAST_PYCALL
+    #define CYTHON_FAST_PYCALL 1
+  #endif
+#endif
+#if !defined(CYTHON_FAST_PYCCALL)
+#define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
+#endif
+#if CYTHON_USE_PYLONG_INTERNALS
+  #include "longintrepr.h"
+  #undef SHIFT
+  #undef BASE
+  #undef MASK
+#endif
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
+  #define Py_OptimizeFlag 0
+#endif
+#define __PYX_BUILD_PY_SSIZE_T "n"
+#define CYTHON_FORMAT_SSIZE_T "z"
+#if PY_MAJOR_VERSION < 3
+  #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
+  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+  #define __Pyx_DefaultClassType PyClass_Type
+#else
+  #define __Pyx_BUILTIN_MODULE_NAME "builtins"
+  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+  #define __Pyx_DefaultClassType PyType_Type
+#endif
+#ifndef Py_TPFLAGS_CHECKTYPES
+  #define Py_TPFLAGS_CHECKTYPES 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_INDEX
+  #define Py_TPFLAGS_HAVE_INDEX 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
+  #define Py_TPFLAGS_HAVE_NEWBUFFER 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_FINALIZE
+  #define Py_TPFLAGS_HAVE_FINALIZE 0
+#endif
+#ifndef METH_FASTCALL
+  #define METH_FASTCALL 0x80
+  typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject **args,
+                                              Py_ssize_t nargs, PyObject *kwnames);
+#else
+  #define __Pyx_PyCFunctionFast _PyCFunctionFast
+#endif
+#if CYTHON_FAST_PYCCALL
+#define __Pyx_PyFastCFunction_Check(func)\
+    ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST)))))
+#else
+#define __Pyx_PyFastCFunction_Check(func) 0
+#endif
+#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+  #define CYTHON_PEP393_ENABLED 1
+  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
+                                              0 : _PyUnicode_Ready((PyObject *)(op)))
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
+  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
+  #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
+  #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, ch)
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+#else
+  #define CYTHON_PEP393_ENABLED 0
+  #define PyUnicode_1BYTE_KIND  1
+  #define PyUnicode_2BYTE_KIND  2
+  #define PyUnicode_4BYTE_KIND  4
+  #define __Pyx_PyUnicode_READY(op)       (0)
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
+  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
+  #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
+  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
+#endif
+#if CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyUnicode_Concat(a, b)      PyNumber_Add(a, b)
+  #define __Pyx_PyUnicode_ConcatSafe(a, b)  PyNumber_Add(a, b)
+#else
+  #define __Pyx_PyUnicode_Concat(a, b)      PyUnicode_Concat(a, b)
+  #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
+      PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
+  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
+  #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
+  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
+  #define PyObject_Malloc(s)   PyMem_Malloc(s)
+  #define PyObject_Free(p)     PyMem_Free(p)
+  #define PyObject_Realloc(p)  PyMem_Realloc(p)
+#endif
+#if CYTHON_COMPILING_IN_PYSTON
+  #define __Pyx_PyCode_HasFreeVars(co)  PyCode_HasFreeVars(co)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
+#else
+  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
+#endif
+#define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
+#define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyString_Format(a, b)  PyUnicode_Format(a, b)
+#else
+  #define __Pyx_PyString_Format(a, b)  PyString_Format(a, b)
+#endif
+#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)
+  #define PyObject_ASCII(o)            PyObject_Repr(o)
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define PyBaseString_Type            PyUnicode_Type
+  #define PyStringObject               PyUnicodeObject
+  #define PyString_Type                PyUnicode_Type
+  #define PyString_Check               PyUnicode_Check
+  #define PyString_CheckExact          PyUnicode_CheckExact
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)
+  #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)
+#else
+  #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
+  #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
+#endif
+#ifndef PySet_CheckExact
+  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
+#endif
+#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
+#if PY_MAJOR_VERSION >= 3
+  #define PyIntObject                  PyLongObject
+  #define PyInt_Type                   PyLong_Type
+  #define PyInt_Check(op)              PyLong_Check(op)
+  #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
+  #define PyInt_FromString             PyLong_FromString
+  #define PyInt_FromUnicode            PyLong_FromUnicode
+  #define PyInt_FromLong               PyLong_FromLong
+  #define PyInt_FromSize_t             PyLong_FromSize_t
+  #define PyInt_FromSsize_t            PyLong_FromSsize_t
+  #define PyInt_AsLong                 PyLong_AsLong
+  #define PyInt_AS_LONG                PyLong_AS_LONG
+  #define PyInt_AsSsize_t              PyLong_AsSsize_t
+  #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
+  #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
+  #define PyNumber_Int                 PyNumber_Long
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define PyBoolObject                 PyLongObject
+#endif
+#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY
+  #ifndef PyUnicode_InternFromString
+    #define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
+  #endif
+#endif
+#if PY_VERSION_HEX < 0x030200A4
+  typedef long Py_hash_t;
+  #define __Pyx_PyInt_FromHash_t PyInt_FromLong
+  #define __Pyx_PyInt_AsHash_t   PyInt_AsLong
+#else
+  #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
+  #define __Pyx_PyInt_AsHash_t   PyInt_AsSsize_t
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func))
+#else
+  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
+#endif
+#if CYTHON_USE_ASYNC_SLOTS
+  #if PY_VERSION_HEX >= 0x030500B1
+    #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
+    #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async)
+  #else
+    typedef struct {
+        unaryfunc am_await;
+        unaryfunc am_aiter;
+        unaryfunc am_anext;
+    } __Pyx_PyAsyncMethodsStruct;
+    #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))
+  #endif
+#else
+  #define __Pyx_PyType_AsAsync(obj) NULL
+#endif
+#ifndef CYTHON_RESTRICT
+  #if defined(__GNUC__)
+    #define CYTHON_RESTRICT __restrict__
+  #elif defined(_MSC_VER) && _MSC_VER >= 1400
+    #define CYTHON_RESTRICT __restrict
+  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define CYTHON_RESTRICT restrict
+  #else
+    #define CYTHON_RESTRICT
+  #endif
+#endif
+#ifndef CYTHON_UNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define CYTHON_UNUSED __attribute__ ((__unused__))
+#   else
+#     define CYTHON_UNUSED
+#   endif
+# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))
+#   define CYTHON_UNUSED __attribute__ ((__unused__))
+# else
+#   define CYTHON_UNUSED
+# endif
+#endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+#  if defined(__cplusplus)
+     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+#  else
+#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+#  endif
+#endif
+#ifndef CYTHON_NCP_UNUSED
+# if CYTHON_COMPILING_IN_CPYTHON
+#  define CYTHON_NCP_UNUSED
+# else
+#  define CYTHON_NCP_UNUSED CYTHON_UNUSED
+# endif
+#endif
+#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
+
+#ifndef CYTHON_INLINE
+  #if defined(__clang__)
+    #define CYTHON_INLINE __inline__ __attribute__ ((__unused__))
+  #elif defined(__GNUC__)
+    #define CYTHON_INLINE __inline__
+  #elif defined(_MSC_VER)
+    #define CYTHON_INLINE __inline
+  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define CYTHON_INLINE inline
+  #else
+    #define CYTHON_INLINE
+  #endif
+#endif
+
+#if defined(WIN32) || defined(MS_WINDOWS)
+  #define _USE_MATH_DEFINES
+#endif
+#include <math.h>
+#ifdef NAN
+#define __PYX_NAN() ((float) NAN)
+#else
+static CYTHON_INLINE float __PYX_NAN() {
+  float value;
+  memset(&value, 0xFF, sizeof(value));
+  return value;
+}
+#endif
+#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL)
+#define __Pyx_truncl trunc
+#else
+#define __Pyx_truncl truncl
+#endif
+
+
+#define __PYX_ERR(f_index, lineno, Ln_error) \
+{ \
+  __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \
+}
+
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_TrueDivide(x,y)
+  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceTrueDivide(x,y)
+#else
+  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
+  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
+#endif
+
+#ifndef __PYX_EXTERN_C
+  #ifdef __cplusplus
+    #define __PYX_EXTERN_C extern "C"
+  #else
+    #define __PYX_EXTERN_C extern
+  #endif
+#endif
+
+#define __PYX_HAVE__cython_nms
+#define __PYX_HAVE_API__cython_nms
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "numpy/arrayobject.h"
+#include "numpy/ufuncobject.h"
+#ifdef _OPENMP
+#include <omp.h>
+#endif /* _OPENMP */
+
+#ifdef PYREX_WITHOUT_ASSERTIONS
+#define CYTHON_WITHOUT_ASSERTIONS
+#endif
+
+typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding;
+                const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;
+
+#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0
+#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0
+#define __PYX_DEFAULT_STRING_ENCODING ""
+#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString
+#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
+#define __Pyx_uchar_cast(c) ((unsigned char)c)
+#define __Pyx_long_cast(x) ((long)x)
+#define __Pyx_fits_Py_ssize_t(v, type, is_signed)  (\
+    (sizeof(type) < sizeof(Py_ssize_t))  ||\
+    (sizeof(type) > sizeof(Py_ssize_t) &&\
+          likely(v < (type)PY_SSIZE_T_MAX ||\
+                 v == (type)PY_SSIZE_T_MAX)  &&\
+          (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\
+                                v == (type)PY_SSIZE_T_MIN)))  ||\
+    (sizeof(type) == sizeof(Py_ssize_t) &&\
+          (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\
+                               v == (type)PY_SSIZE_T_MAX)))  )
+#if defined (__cplusplus) && __cplusplus >= 201103L
+    #include <cstdlib>
+    #define __Pyx_sst_abs(value) std::abs(value)
+#elif SIZEOF_INT >= SIZEOF_SIZE_T
+    #define __Pyx_sst_abs(value) abs(value)
+#elif SIZEOF_LONG >= SIZEOF_SIZE_T
+    #define __Pyx_sst_abs(value) labs(value)
+#elif defined (_MSC_VER) && defined (_M_X64)
+    #define __Pyx_sst_abs(value) _abs64(value)
+#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define __Pyx_sst_abs(value) llabs(value)
+#elif defined (__GNUC__)
+    #define __Pyx_sst_abs(value) __builtin_llabs(value)
+#else
+    #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
+#endif
+static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*);
+static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
+#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
+#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
+#define __Pyx_PyBytes_FromString        PyBytes_FromString
+#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
+#if PY_MAJOR_VERSION < 3
+    #define __Pyx_PyStr_FromString        __Pyx_PyBytes_FromString
+    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
+#else
+    #define __Pyx_PyStr_FromString        __Pyx_PyUnicode_FromString
+    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize
+#endif
+#define __Pyx_PyObject_AsSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
+#define __Pyx_PyBytes_FromCString(s)   __Pyx_PyBytes_FromString((const char*)s)
+#define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
+#define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
+#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
+#if PY_MAJOR_VERSION < 3
+static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u)
+{
+    const Py_UNICODE *u_end = u;
+    while (*u_end++) ;
+    return (size_t)(u_end - u - 1);
+}
+#else
+#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen
+#endif
+#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
+#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
+#define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
+#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
+#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
+#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False))
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
+#if CYTHON_ASSUME_SAFE_MACROS
+#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
+#else
+#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
+#endif
+#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))
+#if PY_MAJOR_VERSION >= 3
+#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))
+#else
+#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
+#endif
+#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+static int __Pyx_sys_getdefaultencoding_not_ascii;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+    PyObject* sys;
+    PyObject* default_encoding = NULL;
+    PyObject* ascii_chars_u = NULL;
+    PyObject* ascii_chars_b = NULL;
+    const char* default_encoding_c;
+    sys = PyImport_ImportModule("sys");
+    if (!sys) goto bad;
+    default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL);
+    Py_DECREF(sys);
+    if (!default_encoding) goto bad;
+    default_encoding_c = PyBytes_AsString(default_encoding);
+    if (!default_encoding_c) goto bad;
+    if (strcmp(default_encoding_c, "ascii") == 0) {
+        __Pyx_sys_getdefaultencoding_not_ascii = 0;
+    } else {
+        char ascii_chars[128];
+        int c;
+        for (c = 0; c < 128; c++) {
+            ascii_chars[c] = c;
+        }
+        __Pyx_sys_getdefaultencoding_not_ascii = 1;
+        ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
+        if (!ascii_chars_u) goto bad;
+        ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);
+        if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) {
+            PyErr_Format(
+                PyExc_ValueError,
+                "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.",
+                default_encoding_c);
+            goto bad;
+        }
+        Py_DECREF(ascii_chars_u);
+        Py_DECREF(ascii_chars_b);
+    }
+    Py_DECREF(default_encoding);
+    return 0;
+bad:
+    Py_XDECREF(default_encoding);
+    Py_XDECREF(ascii_chars_u);
+    Py_XDECREF(ascii_chars_b);
+    return -1;
+}
+#endif
+#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3
+#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
+#else
+#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
+#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+static char* __PYX_DEFAULT_STRING_ENCODING;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+    PyObject* sys;
+    PyObject* default_encoding = NULL;
+    char* default_encoding_c;
+    sys = PyImport_ImportModule("sys");
+    if (!sys) goto bad;
+    default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL);
+    Py_DECREF(sys);
+    if (!default_encoding) goto bad;
+    default_encoding_c = PyBytes_AsString(default_encoding);
+    if (!default_encoding_c) goto bad;
+    __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c));
+    if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;
+    strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);
+    Py_DECREF(default_encoding);
+    return 0;
+bad:
+    Py_XDECREF(default_encoding);
+    return -1;
+}
+#endif
+#endif
+
+
+/* Test for GCC > 2.95 */
+#if defined(__GNUC__)     && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
+  #define likely(x)   __builtin_expect(!!(x), 1)
+  #define unlikely(x) __builtin_expect(!!(x), 0)
+#else /* !__GNUC__ or GCC < 2.95 */
+  #define likely(x)   (x)
+  #define unlikely(x) (x)
+#endif /* __GNUC__ */
+
+static PyObject *__pyx_m;
+static PyObject *__pyx_d;
+static PyObject *__pyx_b;
+static PyObject *__pyx_empty_tuple;
+static PyObject *__pyx_empty_bytes;
+static PyObject *__pyx_empty_unicode;
+static int __pyx_lineno;
+static int __pyx_clineno = 0;
+static const char * __pyx_cfilenm= __FILE__;
+static const char *__pyx_filename;
+
+/* Header.proto */
+#if !defined(CYTHON_CCOMPLEX)
+  #if defined(__cplusplus)
+    #define CYTHON_CCOMPLEX 1
+  #elif defined(_Complex_I)
+    #define CYTHON_CCOMPLEX 1
+  #else
+    #define CYTHON_CCOMPLEX 0
+  #endif
+#endif
+#if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    #include <complex>
+  #else
+    #include <complex.h>
+  #endif
+#endif
+#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__)
+  #undef _Complex_I
+  #define _Complex_I 1.0fj
+#endif
+
+
+static const char *__pyx_f[] = {
+  "_utils/nms.pyx",
+  "__init__.pxd",
+  "type.pxd",
+};
+/* BufferFormatStructs.proto */
+#define IS_UNSIGNED(type) (((type) -1) > 0)
+struct __Pyx_StructField_;
+#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0)
+typedef struct {
+  const char* name;
+  struct __Pyx_StructField_* fields;
+  size_t size;
+  size_t arraysize[8];
+  int ndim;
+  char typegroup;
+  char is_unsigned;
+  int flags;
+} __Pyx_TypeInfo;
+typedef struct __Pyx_StructField_ {
+  __Pyx_TypeInfo* type;
+  const char* name;
+  size_t offset;
+} __Pyx_StructField;
+typedef struct {
+  __Pyx_StructField* field;
+  size_t parent_offset;
+} __Pyx_BufFmt_StackElem;
+typedef struct {
+  __Pyx_StructField root;
+  __Pyx_BufFmt_StackElem* head;
+  size_t fmt_offset;
+  size_t new_count, enc_count;
+  size_t struct_alignment;
+  int is_complex;
+  char enc_type;
+  char new_packmode;
+  char enc_packmode;
+  char is_valid_array;
+} __Pyx_BufFmt_Context;
+
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":725
+ * # in Cython to enable them only on the right systems.
+ * 
+ * ctypedef npy_int8       int8_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_int16      int16_t
+ * ctypedef npy_int32      int32_t
+ */
+typedef npy_int8 __pyx_t_5numpy_int8_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":726
+ * 
+ * ctypedef npy_int8       int8_t
+ * ctypedef npy_int16      int16_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_int32      int32_t
+ * ctypedef npy_int64      int64_t
+ */
+typedef npy_int16 __pyx_t_5numpy_int16_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":727
+ * ctypedef npy_int8       int8_t
+ * ctypedef npy_int16      int16_t
+ * ctypedef npy_int32      int32_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_int64      int64_t
+ * #ctypedef npy_int96      int96_t
+ */
+typedef npy_int32 __pyx_t_5numpy_int32_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":728
+ * ctypedef npy_int16      int16_t
+ * ctypedef npy_int32      int32_t
+ * ctypedef npy_int64      int64_t             # <<<<<<<<<<<<<<
+ * #ctypedef npy_int96      int96_t
+ * #ctypedef npy_int128     int128_t
+ */
+typedef npy_int64 __pyx_t_5numpy_int64_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":732
+ * #ctypedef npy_int128     int128_t
+ * 
+ * ctypedef npy_uint8      uint8_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_uint16     uint16_t
+ * ctypedef npy_uint32     uint32_t
+ */
+typedef npy_uint8 __pyx_t_5numpy_uint8_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":733
+ * 
+ * ctypedef npy_uint8      uint8_t
+ * ctypedef npy_uint16     uint16_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_uint32     uint32_t
+ * ctypedef npy_uint64     uint64_t
+ */
+typedef npy_uint16 __pyx_t_5numpy_uint16_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":734
+ * ctypedef npy_uint8      uint8_t
+ * ctypedef npy_uint16     uint16_t
+ * ctypedef npy_uint32     uint32_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_uint64     uint64_t
+ * #ctypedef npy_uint96     uint96_t
+ */
+typedef npy_uint32 __pyx_t_5numpy_uint32_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":735
+ * ctypedef npy_uint16     uint16_t
+ * ctypedef npy_uint32     uint32_t
+ * ctypedef npy_uint64     uint64_t             # <<<<<<<<<<<<<<
+ * #ctypedef npy_uint96     uint96_t
+ * #ctypedef npy_uint128    uint128_t
+ */
+typedef npy_uint64 __pyx_t_5numpy_uint64_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":739
+ * #ctypedef npy_uint128    uint128_t
+ * 
+ * ctypedef npy_float32    float32_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_float64    float64_t
+ * #ctypedef npy_float80    float80_t
+ */
+typedef npy_float32 __pyx_t_5numpy_float32_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":740
+ * 
+ * ctypedef npy_float32    float32_t
+ * ctypedef npy_float64    float64_t             # <<<<<<<<<<<<<<
+ * #ctypedef npy_float80    float80_t
+ * #ctypedef npy_float128   float128_t
+ */
+typedef npy_float64 __pyx_t_5numpy_float64_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":749
+ * # The int types are mapped a bit surprising --
+ * # numpy.int corresponds to 'l' and numpy.long to 'q'
+ * ctypedef npy_long       int_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_longlong   long_t
+ * ctypedef npy_longlong   longlong_t
+ */
+typedef npy_long __pyx_t_5numpy_int_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":750
+ * # numpy.int corresponds to 'l' and numpy.long to 'q'
+ * ctypedef npy_long       int_t
+ * ctypedef npy_longlong   long_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_longlong   longlong_t
+ * 
+ */
+typedef npy_longlong __pyx_t_5numpy_long_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":751
+ * ctypedef npy_long       int_t
+ * ctypedef npy_longlong   long_t
+ * ctypedef npy_longlong   longlong_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_ulong      uint_t
+ */
+typedef npy_longlong __pyx_t_5numpy_longlong_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":753
+ * ctypedef npy_longlong   longlong_t
+ * 
+ * ctypedef npy_ulong      uint_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_ulonglong  ulong_t
+ * ctypedef npy_ulonglong  ulonglong_t
+ */
+typedef npy_ulong __pyx_t_5numpy_uint_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":754
+ * 
+ * ctypedef npy_ulong      uint_t
+ * ctypedef npy_ulonglong  ulong_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_ulonglong  ulonglong_t
+ * 
+ */
+typedef npy_ulonglong __pyx_t_5numpy_ulong_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":755
+ * ctypedef npy_ulong      uint_t
+ * ctypedef npy_ulonglong  ulong_t
+ * ctypedef npy_ulonglong  ulonglong_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_intp       intp_t
+ */
+typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":757
+ * ctypedef npy_ulonglong  ulonglong_t
+ * 
+ * ctypedef npy_intp       intp_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_uintp      uintp_t
+ * 
+ */
+typedef npy_intp __pyx_t_5numpy_intp_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":758
+ * 
+ * ctypedef npy_intp       intp_t
+ * ctypedef npy_uintp      uintp_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_double     float_t
+ */
+typedef npy_uintp __pyx_t_5numpy_uintp_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":760
+ * ctypedef npy_uintp      uintp_t
+ * 
+ * ctypedef npy_double     float_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_double     double_t
+ * ctypedef npy_longdouble longdouble_t
+ */
+typedef npy_double __pyx_t_5numpy_float_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":761
+ * 
+ * ctypedef npy_double     float_t
+ * ctypedef npy_double     double_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_longdouble longdouble_t
+ * 
+ */
+typedef npy_double __pyx_t_5numpy_double_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":762
+ * ctypedef npy_double     float_t
+ * ctypedef npy_double     double_t
+ * ctypedef npy_longdouble longdouble_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_cfloat      cfloat_t
+ */
+typedef npy_longdouble __pyx_t_5numpy_longdouble_t;
+/* Declarations.proto */
+#if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    typedef ::std::complex< float > __pyx_t_float_complex;
+  #else
+    typedef float _Complex __pyx_t_float_complex;
+  #endif
+#else
+    typedef struct { float real, imag; } __pyx_t_float_complex;
+#endif
+static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float);
+
+/* Declarations.proto */
+#if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    typedef ::std::complex< double > __pyx_t_double_complex;
+  #else
+    typedef double _Complex __pyx_t_double_complex;
+  #endif
+#else
+    typedef struct { double real, imag; } __pyx_t_double_complex;
+#endif
+static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double);
+
+
+/*--- Type declarations ---*/
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":764
+ * ctypedef npy_longdouble longdouble_t
+ * 
+ * ctypedef npy_cfloat      cfloat_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_cdouble     cdouble_t
+ * ctypedef npy_clongdouble clongdouble_t
+ */
+typedef npy_cfloat __pyx_t_5numpy_cfloat_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":765
+ * 
+ * ctypedef npy_cfloat      cfloat_t
+ * ctypedef npy_cdouble     cdouble_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_clongdouble clongdouble_t
+ * 
+ */
+typedef npy_cdouble __pyx_t_5numpy_cdouble_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":766
+ * ctypedef npy_cfloat      cfloat_t
+ * ctypedef npy_cdouble     cdouble_t
+ * ctypedef npy_clongdouble clongdouble_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_cdouble     complex_t
+ */
+typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t;
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":768
+ * ctypedef npy_clongdouble clongdouble_t
+ * 
+ * ctypedef npy_cdouble     complex_t             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew1(a):
+ */
+typedef npy_cdouble __pyx_t_5numpy_complex_t;
+
+/* --- Runtime support code (head) --- */
+/* Refnanny.proto */
+#ifndef CYTHON_REFNANNY
+  #define CYTHON_REFNANNY 0
+#endif
+#if CYTHON_REFNANNY
+  typedef struct {
+    void (*INCREF)(void*, PyObject*, int);
+    void (*DECREF)(void*, PyObject*, int);
+    void (*GOTREF)(void*, PyObject*, int);
+    void (*GIVEREF)(void*, PyObject*, int);
+    void* (*SetupContext)(const char*, int, const char*);
+    void (*FinishContext)(void**);
+  } __Pyx_RefNannyAPIStruct;
+  static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
+  static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);
+  #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;
+#ifdef WITH_THREAD
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
+          if (acquire_gil) {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              PyGILState_Release(__pyx_gilstate_save);\
+          } else {\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+          }
+#else
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
+          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+#endif
+  #define __Pyx_RefNannyFinishContext()\
+          __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
+  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
+  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
+  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
+  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
+#else
+  #define __Pyx_RefNannyDeclarations
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContext()
+  #define __Pyx_INCREF(r) Py_INCREF(r)
+  #define __Pyx_DECREF(r) Py_DECREF(r)
+  #define __Pyx_GOTREF(r)
+  #define __Pyx_GIVEREF(r)
+  #define __Pyx_XINCREF(r) Py_XINCREF(r)
+  #define __Pyx_XDECREF(r) Py_XDECREF(r)
+  #define __Pyx_XGOTREF(r)
+  #define __Pyx_XGIVEREF(r)
+#endif
+#define __Pyx_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; __Pyx_XDECREF(tmp);\
+    } while (0)
+#define __Pyx_DECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; __Pyx_DECREF(tmp);\
+    } while (0)
+#define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
+#define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
+
+/* PyObjectGetAttrStr.proto */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro))
+        return tp->tp_getattro(obj, attr_name);
+#if PY_MAJOR_VERSION < 3
+    if (likely(tp->tp_getattr))
+        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
+#endif
+    return PyObject_GetAttr(obj, attr_name);
+}
+#else
+#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
+#endif
+
+/* GetBuiltinName.proto */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name);
+
+/* RaiseArgTupleInvalid.proto */
+static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
+    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
+
+/* RaiseDoubleKeywords.proto */
+static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
+
+/* ParseKeywords.proto */
+static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
+    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
+    const char* function_name);
+
+/* ArgTypeTest.proto */
+static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,
+    const char *name, int exact);
+
+/* BufferFormatCheck.proto */
+static CYTHON_INLINE int  __Pyx_GetBufferAndValidate(Py_buffer* buf, PyObject* obj,
+    __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack);
+static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info);
+static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts);
+static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,
+                              __Pyx_BufFmt_StackElem* stack,
+                              __Pyx_TypeInfo* type); // PROTO
+
+/* ExtTypeTest.proto */
+static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type);
+
+/* PyIntBinop.proto */
+#if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace);
+#else
+#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace)\
+    (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2))
+#endif
+
+/* PyCFunctionFastCall.proto */
+#if CYTHON_FAST_PYCCALL
+static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs);
+#else
+#define __Pyx_PyCFunction_FastCall(func, args, nargs)  (assert(0), NULL)
+#endif
+
+/* PyFunctionFastCall.proto */
+#if CYTHON_FAST_PYCALL
+#define __Pyx_PyFunction_FastCall(func, args, nargs)\
+    __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
+#if 1 || PY_VERSION_HEX < 0x030600B1
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs);
+#else
+#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs)
+#endif
+#endif
+
+/* PyObjectCall.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
+#else
+#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
+#endif
+
+/* PyObjectCallMethO.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
+#endif
+
+/* PyObjectCallOneArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+
+/* PyObjectCallNoArg.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
+#else
+#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL)
+#endif
+
+/* GetModuleGlobalName.proto */
+static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name);
+
+/* BufferIndexError.proto */
+static void __Pyx_RaiseBufferIndexError(int axis);
+
+#define __Pyx_BufPtrStrided1d(type, buf, i0, s0) (type)((char*)buf + i0 * s0)
+/* ListAppend.proto */
+#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
+static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
+    PyListObject* L = (PyListObject*) list;
+    Py_ssize_t len = Py_SIZE(list);
+    if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) {
+        Py_INCREF(x);
+        PyList_SET_ITEM(list, len, x);
+        Py_SIZE(list) = len+1;
+        return 0;
+    }
+    return PyList_Append(list, x);
+}
+#else
+#define __Pyx_PyList_Append(L,x) PyList_Append(L,x)
+#endif
+
+/* PyThreadStateGet.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
+#define __Pyx_PyThreadState_assign  __pyx_tstate = PyThreadState_GET();
+#else
+#define __Pyx_PyThreadState_declare
+#define __Pyx_PyThreadState_assign
+#endif
+
+/* PyErrFetchRestore.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#else
+#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
+#endif
+
+/* RaiseException.proto */
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
+
+/* DictGetItem.proto */
+#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
+static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
+    PyObject *value;
+    value = PyDict_GetItemWithError(d, key);
+    if (unlikely(!value)) {
+        if (!PyErr_Occurred()) {
+            PyObject* args = PyTuple_Pack(1, key);
+            if (likely(args))
+                PyErr_SetObject(PyExc_KeyError, args);
+            Py_XDECREF(args);
+        }
+        return NULL;
+    }
+    Py_INCREF(value);
+    return value;
+}
+#else
+    #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key)
+#endif
+
+/* RaiseTooManyValuesToUnpack.proto */
+static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);
+
+/* RaiseNeedMoreValuesToUnpack.proto */
+static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);
+
+/* RaiseNoneIterError.proto */
+static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);
+
+/* SaveResetException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_ExceptionSave(type, value, tb)  __Pyx__ExceptionSave(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#define __Pyx_ExceptionReset(type, value, tb)  __Pyx__ExceptionReset(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+#else
+#define __Pyx_ExceptionSave(type, value, tb)   PyErr_GetExcInfo(type, value, tb)
+#define __Pyx_ExceptionReset(type, value, tb)  PyErr_SetExcInfo(type, value, tb)
+#endif
+
+/* PyErrExceptionMatches.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
+#else
+#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
+#endif
+
+/* GetException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_GetException(type, value, tb)  __Pyx__GetException(__pyx_tstate, type, value, tb)
+static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#else
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb);
+#endif
+
+/* Import.proto */
+static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);
+
+/* CodeObjectCache.proto */
+typedef struct {
+    PyCodeObject* code_object;
+    int code_line;
+} __Pyx_CodeObjectCacheEntry;
+struct __Pyx_CodeObjectCache {
+    int count;
+    int max_count;
+    __Pyx_CodeObjectCacheEntry* entries;
+};
+static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
+static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
+static PyCodeObject *__pyx_find_code_object(int code_line);
+static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
+
+/* AddTraceback.proto */
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename);
+
+/* BufferStructDeclare.proto */
+typedef struct {
+  Py_ssize_t shape, strides, suboffsets;
+} __Pyx_Buf_DimInfo;
+typedef struct {
+  size_t refcount;
+  Py_buffer pybuffer;
+} __Pyx_Buffer;
+typedef struct {
+  __Pyx_Buffer *rcbuffer;
+  char *data;
+  __Pyx_Buf_DimInfo diminfo[8];
+} __Pyx_LocalBuf_ND;
+
+#if PY_MAJOR_VERSION < 3
+    static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags);
+    static void __Pyx_ReleaseBuffer(Py_buffer *view);
+#else
+    #define __Pyx_GetBuffer PyObject_GetBuffer
+    #define __Pyx_ReleaseBuffer PyBuffer_Release
+#endif
+
+
+/* None.proto */
+static Py_ssize_t __Pyx_zeros[] = {0, 0, 0, 0, 0, 0, 0, 0};
+static Py_ssize_t __Pyx_minusones[] = {-1, -1, -1, -1, -1, -1, -1, -1};
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
+
+/* RealImag.proto */
+#if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    #define __Pyx_CREAL(z) ((z).real())
+    #define __Pyx_CIMAG(z) ((z).imag())
+  #else
+    #define __Pyx_CREAL(z) (__real__(z))
+    #define __Pyx_CIMAG(z) (__imag__(z))
+  #endif
+#else
+    #define __Pyx_CREAL(z) ((z).real)
+    #define __Pyx_CIMAG(z) ((z).imag)
+#endif
+#if defined(__cplusplus) && CYTHON_CCOMPLEX\
+        && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103)
+    #define __Pyx_SET_CREAL(z,x) ((z).real(x))
+    #define __Pyx_SET_CIMAG(z,y) ((z).imag(y))
+#else
+    #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x)
+    #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y)
+#endif
+
+/* Arithmetic.proto */
+#if CYTHON_CCOMPLEX
+    #define __Pyx_c_eq_float(a, b)   ((a)==(b))
+    #define __Pyx_c_sum_float(a, b)  ((a)+(b))
+    #define __Pyx_c_diff_float(a, b) ((a)-(b))
+    #define __Pyx_c_prod_float(a, b) ((a)*(b))
+    #define __Pyx_c_quot_float(a, b) ((a)/(b))
+    #define __Pyx_c_neg_float(a)     (-(a))
+  #ifdef __cplusplus
+    #define __Pyx_c_is_zero_float(z) ((z)==(float)0)
+    #define __Pyx_c_conj_float(z)    (::std::conj(z))
+    #if 1
+        #define __Pyx_c_abs_float(z)     (::std::abs(z))
+        #define __Pyx_c_pow_float(a, b)  (::std::pow(a, b))
+    #endif
+  #else
+    #define __Pyx_c_is_zero_float(z) ((z)==0)
+    #define __Pyx_c_conj_float(z)    (conjf(z))
+    #if 1
+        #define __Pyx_c_abs_float(z)     (cabsf(z))
+        #define __Pyx_c_pow_float(a, b)  (cpowf(a, b))
+    #endif
+ #endif
+#else
+    static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex);
+    static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex);
+    #if 1
+        static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex);
+        static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    #endif
+#endif
+
+/* Arithmetic.proto */
+#if CYTHON_CCOMPLEX
+    #define __Pyx_c_eq_double(a, b)   ((a)==(b))
+    #define __Pyx_c_sum_double(a, b)  ((a)+(b))
+    #define __Pyx_c_diff_double(a, b) ((a)-(b))
+    #define __Pyx_c_prod_double(a, b) ((a)*(b))
+    #define __Pyx_c_quot_double(a, b) ((a)/(b))
+    #define __Pyx_c_neg_double(a)     (-(a))
+  #ifdef __cplusplus
+    #define __Pyx_c_is_zero_double(z) ((z)==(double)0)
+    #define __Pyx_c_conj_double(z)    (::std::conj(z))
+    #if 1
+        #define __Pyx_c_abs_double(z)     (::std::abs(z))
+        #define __Pyx_c_pow_double(a, b)  (::std::pow(a, b))
+    #endif
+  #else
+    #define __Pyx_c_is_zero_double(z) ((z)==0)
+    #define __Pyx_c_conj_double(z)    (conj(z))
+    #if 1
+        #define __Pyx_c_abs_double(z)     (cabs(z))
+        #define __Pyx_c_pow_double(a, b)  (cpow(a, b))
+    #endif
+ #endif
+#else
+    static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex);
+    static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex);
+    #if 1
+        static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex);
+        static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    #endif
+#endif
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
+
+/* CheckBinaryVersion.proto */
+static int __Pyx_check_binary_version(void);
+
+/* PyIdentifierFromString.proto */
+#if !defined(__Pyx_PyIdentifier_FromString)
+#if PY_MAJOR_VERSION < 3
+  #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s)
+#else
+  #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s)
+#endif
+#endif
+
+/* ModuleImport.proto */
+static PyObject *__Pyx_ImportModule(const char *name);
+
+/* TypeImport.proto */
+static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict);
+
+/* InitStrings.proto */
+static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
+
+
+/* Module declarations from 'cpython.buffer' */
+
+/* Module declarations from 'libc.string' */
+
+/* Module declarations from 'libc.stdio' */
+
+/* Module declarations from '__builtin__' */
+
+/* Module declarations from 'cpython.type' */
+static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0;
+
+/* Module declarations from 'cpython' */
+
+/* Module declarations from 'cpython.object' */
+
+/* Module declarations from 'cpython.ref' */
+
+/* Module declarations from 'libc.stdlib' */
+
+/* Module declarations from 'numpy' */
+
+/* Module declarations from 'numpy' */
+static PyTypeObject *__pyx_ptype_5numpy_dtype = 0;
+static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0;
+static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0;
+static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0;
+static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0;
+static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/
+
+/* Module declarations from 'cython_nms' */
+static CYTHON_INLINE __pyx_t_5numpy_float32_t __pyx_f_10cython_nms_max(__pyx_t_5numpy_float32_t, __pyx_t_5numpy_float32_t); /*proto*/
+static CYTHON_INLINE __pyx_t_5numpy_float32_t __pyx_f_10cython_nms_min(__pyx_t_5numpy_float32_t, __pyx_t_5numpy_float32_t); /*proto*/
+static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t = { "float32_t", NULL, sizeof(__pyx_t_5numpy_float32_t), { 0 }, 0, 'R', 0, 0 };
+static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_int_t = { "int_t", NULL, sizeof(__pyx_t_5numpy_int_t), { 0 }, 0, IS_UNSIGNED(__pyx_t_5numpy_int_t) ? 'U' : 'I', IS_UNSIGNED(__pyx_t_5numpy_int_t), 0 };
+#define __Pyx_MODULE_NAME "cython_nms"
+int __pyx_module_is_main_cython_nms = 0;
+
+/* Implementation of 'cython_nms' */
+static PyObject *__pyx_builtin_range;
+static PyObject *__pyx_builtin_ValueError;
+static PyObject *__pyx_builtin_RuntimeError;
+static PyObject *__pyx_builtin_ImportError;
+static const char __pyx_k_h[] = "h";
+static const char __pyx_k_i[] = "_i";
+static const char __pyx_k_j[] = "_j";
+static const char __pyx_k_w[] = "w";
+static const char __pyx_k_np[] = "np";
+static const char __pyx_k_x1[] = "x1";
+static const char __pyx_k_x2[] = "x2";
+static const char __pyx_k_y1[] = "y1";
+static const char __pyx_k_y2[] = "y2";
+static const char __pyx_k_i_2[] = "i";
+static const char __pyx_k_int[] = "int";
+static const char __pyx_k_ix1[] = "ix1";
+static const char __pyx_k_ix2[] = "ix2";
+static const char __pyx_k_iy1[] = "iy1";
+static const char __pyx_k_iy2[] = "iy2";
+static const char __pyx_k_j_2[] = "j";
+static const char __pyx_k_nms[] = "nms";
+static const char __pyx_k_ovr[] = "ovr";
+static const char __pyx_k_xx1[] = "xx1";
+static const char __pyx_k_xx2[] = "xx2";
+static const char __pyx_k_yy1[] = "yy1";
+static const char __pyx_k_yy2[] = "yy2";
+static const char __pyx_k_dets[] = "dets";
+static const char __pyx_k_keep[] = "keep";
+static const char __pyx_k_main[] = "__main__";
+static const char __pyx_k_ovr1[] = "ovr1";
+static const char __pyx_k_ovr2[] = "ovr2";
+static const char __pyx_k_test[] = "__test__";
+static const char __pyx_k_areas[] = "areas";
+static const char __pyx_k_dtype[] = "dtype";
+static const char __pyx_k_iarea[] = "iarea";
+static const char __pyx_k_inter[] = "inter";
+static const char __pyx_k_ndets[] = "ndets";
+static const char __pyx_k_numpy[] = "numpy";
+static const char __pyx_k_order[] = "order";
+static const char __pyx_k_range[] = "range";
+static const char __pyx_k_zeros[] = "zeros";
+static const char __pyx_k_import[] = "__import__";
+static const char __pyx_k_scores[] = "scores";
+static const char __pyx_k_thresh[] = "thresh";
+static const char __pyx_k_argsort[] = "argsort";
+static const char __pyx_k_nms_new[] = "nms_new";
+static const char __pyx_k_ValueError[] = "ValueError";
+static const char __pyx_k_cython_nms[] = "cython_nms";
+static const char __pyx_k_suppressed[] = "suppressed";
+static const char __pyx_k_ImportError[] = "ImportError";
+static const char __pyx_k_RuntimeError[] = "RuntimeError";
+static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous";
+static const char __pyx_k_home_yjr_PycharmProjects_Faster[] = "/home/yjr/PycharmProjects/Faster-RCNN_Tensorflow/libs/box_utils/cython_utils/nms.pyx";
+static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import";
+static const char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)";
+static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd";
+static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported";
+static const char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous";
+static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import";
+static const char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short.";
+static PyObject *__pyx_kp_u_Format_string_allocated_too_shor;
+static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2;
+static PyObject *__pyx_n_s_ImportError;
+static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor;
+static PyObject *__pyx_n_s_RuntimeError;
+static PyObject *__pyx_n_s_ValueError;
+static PyObject *__pyx_n_s_areas;
+static PyObject *__pyx_n_s_argsort;
+static PyObject *__pyx_n_s_cython_nms;
+static PyObject *__pyx_n_s_dets;
+static PyObject *__pyx_n_s_dtype;
+static PyObject *__pyx_n_s_h;
+static PyObject *__pyx_kp_s_home_yjr_PycharmProjects_Faster;
+static PyObject *__pyx_n_s_i;
+static PyObject *__pyx_n_s_i_2;
+static PyObject *__pyx_n_s_iarea;
+static PyObject *__pyx_n_s_import;
+static PyObject *__pyx_n_s_int;
+static PyObject *__pyx_n_s_inter;
+static PyObject *__pyx_n_s_ix1;
+static PyObject *__pyx_n_s_ix2;
+static PyObject *__pyx_n_s_iy1;
+static PyObject *__pyx_n_s_iy2;
+static PyObject *__pyx_n_s_j;
+static PyObject *__pyx_n_s_j_2;
+static PyObject *__pyx_n_s_keep;
+static PyObject *__pyx_n_s_main;
+static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous;
+static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou;
+static PyObject *__pyx_n_s_ndets;
+static PyObject *__pyx_n_s_nms;
+static PyObject *__pyx_n_s_nms_new;
+static PyObject *__pyx_n_s_np;
+static PyObject *__pyx_n_s_numpy;
+static PyObject *__pyx_kp_s_numpy_core_multiarray_failed_to;
+static PyObject *__pyx_kp_s_numpy_core_umath_failed_to_impor;
+static PyObject *__pyx_n_s_order;
+static PyObject *__pyx_n_s_ovr;
+static PyObject *__pyx_n_s_ovr1;
+static PyObject *__pyx_n_s_ovr2;
+static PyObject *__pyx_n_s_range;
+static PyObject *__pyx_n_s_scores;
+static PyObject *__pyx_n_s_suppressed;
+static PyObject *__pyx_n_s_test;
+static PyObject *__pyx_n_s_thresh;
+static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd;
+static PyObject *__pyx_n_s_w;
+static PyObject *__pyx_n_s_x1;
+static PyObject *__pyx_n_s_x2;
+static PyObject *__pyx_n_s_xx1;
+static PyObject *__pyx_n_s_xx2;
+static PyObject *__pyx_n_s_y1;
+static PyObject *__pyx_n_s_y2;
+static PyObject *__pyx_n_s_yy1;
+static PyObject *__pyx_n_s_yy2;
+static PyObject *__pyx_n_s_zeros;
+static PyObject *__pyx_pf_10cython_nms_nms(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_dets, PyObject *__pyx_v_thresh); /* proto */
+static PyObject *__pyx_pf_10cython_nms_2nms_new(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_dets, PyObject *__pyx_v_thresh); /* proto */
+static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */
+static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */
+static PyObject *__pyx_float_0_95;
+static PyObject *__pyx_int_0;
+static PyObject *__pyx_int_1;
+static PyObject *__pyx_int_2;
+static PyObject *__pyx_int_3;
+static PyObject *__pyx_int_4;
+static PyObject *__pyx_int_neg_1;
+static PyObject *__pyx_slice_;
+static PyObject *__pyx_slice__3;
+static PyObject *__pyx_slice__5;
+static PyObject *__pyx_slice__7;
+static PyObject *__pyx_slice__9;
+static PyObject *__pyx_tuple__2;
+static PyObject *__pyx_tuple__4;
+static PyObject *__pyx_tuple__6;
+static PyObject *__pyx_tuple__8;
+static PyObject *__pyx_slice__11;
+static PyObject *__pyx_slice__12;
+static PyObject *__pyx_slice__14;
+static PyObject *__pyx_slice__16;
+static PyObject *__pyx_slice__18;
+static PyObject *__pyx_slice__20;
+static PyObject *__pyx_slice__22;
+static PyObject *__pyx_tuple__10;
+static PyObject *__pyx_tuple__13;
+static PyObject *__pyx_tuple__15;
+static PyObject *__pyx_tuple__17;
+static PyObject *__pyx_tuple__19;
+static PyObject *__pyx_tuple__21;
+static PyObject *__pyx_tuple__23;
+static PyObject *__pyx_tuple__24;
+static PyObject *__pyx_tuple__25;
+static PyObject *__pyx_tuple__26;
+static PyObject *__pyx_tuple__27;
+static PyObject *__pyx_tuple__28;
+static PyObject *__pyx_tuple__29;
+static PyObject *__pyx_tuple__30;
+static PyObject *__pyx_tuple__31;
+static PyObject *__pyx_tuple__32;
+static PyObject *__pyx_tuple__34;
+static PyObject *__pyx_codeobj__33;
+static PyObject *__pyx_codeobj__35;
+
+/* "nms.pyx":11
+ * cimport numpy as np
+ * 
+ * cdef inline np.float32_t max(np.float32_t a, np.float32_t b):             # <<<<<<<<<<<<<<
+ *     return a if a >= b else b
+ * 
+ */
+
+static CYTHON_INLINE __pyx_t_5numpy_float32_t __pyx_f_10cython_nms_max(__pyx_t_5numpy_float32_t __pyx_v_a, __pyx_t_5numpy_float32_t __pyx_v_b) {
+  __pyx_t_5numpy_float32_t __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __pyx_t_5numpy_float32_t __pyx_t_1;
+  __Pyx_RefNannySetupContext("max", 0);
+
+  /* "nms.pyx":12
+ * 
+ * cdef inline np.float32_t max(np.float32_t a, np.float32_t b):
+ *     return a if a >= b else b             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline np.float32_t min(np.float32_t a, np.float32_t b):
+ */
+  if (((__pyx_v_a >= __pyx_v_b) != 0)) {
+    __pyx_t_1 = __pyx_v_a;
+  } else {
+    __pyx_t_1 = __pyx_v_b;
+  }
+  __pyx_r = __pyx_t_1;
+  goto __pyx_L0;
+
+  /* "nms.pyx":11
+ * cimport numpy as np
+ * 
+ * cdef inline np.float32_t max(np.float32_t a, np.float32_t b):             # <<<<<<<<<<<<<<
+ *     return a if a >= b else b
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "nms.pyx":14
+ *     return a if a >= b else b
+ * 
+ * cdef inline np.float32_t min(np.float32_t a, np.float32_t b):             # <<<<<<<<<<<<<<
+ *     return a if a <= b else b
+ * 
+ */
+
+static CYTHON_INLINE __pyx_t_5numpy_float32_t __pyx_f_10cython_nms_min(__pyx_t_5numpy_float32_t __pyx_v_a, __pyx_t_5numpy_float32_t __pyx_v_b) {
+  __pyx_t_5numpy_float32_t __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __pyx_t_5numpy_float32_t __pyx_t_1;
+  __Pyx_RefNannySetupContext("min", 0);
+
+  /* "nms.pyx":15
+ * 
+ * cdef inline np.float32_t min(np.float32_t a, np.float32_t b):
+ *     return a if a <= b else b             # <<<<<<<<<<<<<<
+ * 
+ * def nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):
+ */
+  if (((__pyx_v_a <= __pyx_v_b) != 0)) {
+    __pyx_t_1 = __pyx_v_a;
+  } else {
+    __pyx_t_1 = __pyx_v_b;
+  }
+  __pyx_r = __pyx_t_1;
+  goto __pyx_L0;
+
+  /* "nms.pyx":14
+ *     return a if a >= b else b
+ * 
+ * cdef inline np.float32_t min(np.float32_t a, np.float32_t b):             # <<<<<<<<<<<<<<
+ *     return a if a <= b else b
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "nms.pyx":17
+ *     return a if a <= b else b
+ * 
+ * def nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_10cython_nms_1nms(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_10cython_nms_1nms = {"nms", (PyCFunction)__pyx_pw_10cython_nms_1nms, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_10cython_nms_1nms(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyArrayObject *__pyx_v_dets = 0;
+  PyObject *__pyx_v_thresh = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("nms (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_dets,&__pyx_n_s_thresh,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_dets)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_thresh)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("nms", 1, 2, 2, 1); __PYX_ERR(0, 17, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "nms") < 0)) __PYX_ERR(0, 17, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_dets = ((PyArrayObject *)values[0]);
+    __pyx_v_thresh = ((PyObject*)values[1]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("nms", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 17, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("cython_nms.nms", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dets), __pyx_ptype_5numpy_ndarray, 1, "dets", 0))) __PYX_ERR(0, 17, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_thresh), (&PyFloat_Type), 1, "thresh", 1))) __PYX_ERR(0, 17, __pyx_L1_error)
+  __pyx_r = __pyx_pf_10cython_nms_nms(__pyx_self, __pyx_v_dets, __pyx_v_thresh);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_10cython_nms_nms(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_dets, PyObject *__pyx_v_thresh) {
+  PyArrayObject *__pyx_v_x1 = 0;
+  PyArrayObject *__pyx_v_y1 = 0;
+  PyArrayObject *__pyx_v_x2 = 0;
+  PyArrayObject *__pyx_v_y2 = 0;
+  PyArrayObject *__pyx_v_scores = 0;
+  PyArrayObject *__pyx_v_areas = 0;
+  PyArrayObject *__pyx_v_order = 0;
+  int __pyx_v_ndets;
+  PyArrayObject *__pyx_v_suppressed = 0;
+  int __pyx_v__i;
+  int __pyx_v__j;
+  int __pyx_v_i;
+  int __pyx_v_j;
+  __pyx_t_5numpy_float32_t __pyx_v_ix1;
+  __pyx_t_5numpy_float32_t __pyx_v_iy1;
+  __pyx_t_5numpy_float32_t __pyx_v_ix2;
+  __pyx_t_5numpy_float32_t __pyx_v_iy2;
+  __pyx_t_5numpy_float32_t __pyx_v_iarea;
+  __pyx_t_5numpy_float32_t __pyx_v_xx1;
+  __pyx_t_5numpy_float32_t __pyx_v_yy1;
+  __pyx_t_5numpy_float32_t __pyx_v_xx2;
+  __pyx_t_5numpy_float32_t __pyx_v_yy2;
+  __pyx_t_5numpy_float32_t __pyx_v_w;
+  __pyx_t_5numpy_float32_t __pyx_v_h;
+  __pyx_t_5numpy_float32_t __pyx_v_inter;
+  __pyx_t_5numpy_float32_t __pyx_v_ovr;
+  PyObject *__pyx_v_keep = NULL;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_areas;
+  __Pyx_Buffer __pyx_pybuffer_areas;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_dets;
+  __Pyx_Buffer __pyx_pybuffer_dets;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_order;
+  __Pyx_Buffer __pyx_pybuffer_order;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_scores;
+  __Pyx_Buffer __pyx_pybuffer_scores;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_suppressed;
+  __Pyx_Buffer __pyx_pybuffer_suppressed;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_x1;
+  __Pyx_Buffer __pyx_pybuffer_x1;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_x2;
+  __Pyx_Buffer __pyx_pybuffer_x2;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_y1;
+  __Pyx_Buffer __pyx_pybuffer_y1;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_y2;
+  __Pyx_Buffer __pyx_pybuffer_y2;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyArrayObject *__pyx_t_2 = NULL;
+  PyArrayObject *__pyx_t_3 = NULL;
+  PyArrayObject *__pyx_t_4 = NULL;
+  PyArrayObject *__pyx_t_5 = NULL;
+  PyArrayObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  PyArrayObject *__pyx_t_9 = NULL;
+  PyArrayObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyArrayObject *__pyx_t_13 = NULL;
+  int __pyx_t_14;
+  int __pyx_t_15;
+  Py_ssize_t __pyx_t_16;
+  int __pyx_t_17;
+  Py_ssize_t __pyx_t_18;
+  int __pyx_t_19;
+  int __pyx_t_20;
+  Py_ssize_t __pyx_t_21;
+  Py_ssize_t __pyx_t_22;
+  Py_ssize_t __pyx_t_23;
+  Py_ssize_t __pyx_t_24;
+  Py_ssize_t __pyx_t_25;
+  int __pyx_t_26;
+  Py_ssize_t __pyx_t_27;
+  int __pyx_t_28;
+  Py_ssize_t __pyx_t_29;
+  Py_ssize_t __pyx_t_30;
+  Py_ssize_t __pyx_t_31;
+  Py_ssize_t __pyx_t_32;
+  Py_ssize_t __pyx_t_33;
+  Py_ssize_t __pyx_t_34;
+  __pyx_t_5numpy_float32_t __pyx_t_35;
+  Py_ssize_t __pyx_t_36;
+  __Pyx_RefNannySetupContext("nms", 0);
+  __pyx_pybuffer_x1.pybuffer.buf = NULL;
+  __pyx_pybuffer_x1.refcount = 0;
+  __pyx_pybuffernd_x1.data = NULL;
+  __pyx_pybuffernd_x1.rcbuffer = &__pyx_pybuffer_x1;
+  __pyx_pybuffer_y1.pybuffer.buf = NULL;
+  __pyx_pybuffer_y1.refcount = 0;
+  __pyx_pybuffernd_y1.data = NULL;
+  __pyx_pybuffernd_y1.rcbuffer = &__pyx_pybuffer_y1;
+  __pyx_pybuffer_x2.pybuffer.buf = NULL;
+  __pyx_pybuffer_x2.refcount = 0;
+  __pyx_pybuffernd_x2.data = NULL;
+  __pyx_pybuffernd_x2.rcbuffer = &__pyx_pybuffer_x2;
+  __pyx_pybuffer_y2.pybuffer.buf = NULL;
+  __pyx_pybuffer_y2.refcount = 0;
+  __pyx_pybuffernd_y2.data = NULL;
+  __pyx_pybuffernd_y2.rcbuffer = &__pyx_pybuffer_y2;
+  __pyx_pybuffer_scores.pybuffer.buf = NULL;
+  __pyx_pybuffer_scores.refcount = 0;
+  __pyx_pybuffernd_scores.data = NULL;
+  __pyx_pybuffernd_scores.rcbuffer = &__pyx_pybuffer_scores;
+  __pyx_pybuffer_areas.pybuffer.buf = NULL;
+  __pyx_pybuffer_areas.refcount = 0;
+  __pyx_pybuffernd_areas.data = NULL;
+  __pyx_pybuffernd_areas.rcbuffer = &__pyx_pybuffer_areas;
+  __pyx_pybuffer_order.pybuffer.buf = NULL;
+  __pyx_pybuffer_order.refcount = 0;
+  __pyx_pybuffernd_order.data = NULL;
+  __pyx_pybuffernd_order.rcbuffer = &__pyx_pybuffer_order;
+  __pyx_pybuffer_suppressed.pybuffer.buf = NULL;
+  __pyx_pybuffer_suppressed.refcount = 0;
+  __pyx_pybuffernd_suppressed.data = NULL;
+  __pyx_pybuffernd_suppressed.rcbuffer = &__pyx_pybuffer_suppressed;
+  __pyx_pybuffer_dets.pybuffer.buf = NULL;
+  __pyx_pybuffer_dets.refcount = 0;
+  __pyx_pybuffernd_dets.data = NULL;
+  __pyx_pybuffernd_dets.rcbuffer = &__pyx_pybuffer_dets;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_dets.rcbuffer->pybuffer, (PyObject*)__pyx_v_dets, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 17, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_dets.diminfo[0].strides = __pyx_pybuffernd_dets.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_dets.diminfo[0].shape = __pyx_pybuffernd_dets.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_dets.diminfo[1].strides = __pyx_pybuffernd_dets.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_dets.diminfo[1].shape = __pyx_pybuffernd_dets.rcbuffer->pybuffer.shape[1];
+
+  /* "nms.pyx":18
+ * 
+ * def nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):
+ *     cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ *     cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]
+ */
+  __pyx_t_1 = PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_tuple__2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 18, __pyx_L1_error)
+  __pyx_t_2 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x1.rcbuffer->pybuffer, (PyObject*)__pyx_t_2, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_x1 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_x1.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 18, __pyx_L1_error)
+    } else {__pyx_pybuffernd_x1.diminfo[0].strides = __pyx_pybuffernd_x1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x1.diminfo[0].shape = __pyx_pybuffernd_x1.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_2 = 0;
+  __pyx_v_x1 = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "nms.pyx":19
+ * def nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):
+ *     cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3]
+ */
+  __pyx_t_1 = PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_tuple__4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 19, __pyx_L1_error)
+  __pyx_t_3 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_y1.rcbuffer->pybuffer, (PyObject*)__pyx_t_3, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_y1 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_y1.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 19, __pyx_L1_error)
+    } else {__pyx_pybuffernd_y1.diminfo[0].strides = __pyx_pybuffernd_y1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_y1.diminfo[0].shape = __pyx_pybuffernd_y1.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_3 = 0;
+  __pyx_v_y1 = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "nms.pyx":20
+ *     cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ *     cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3]
+ *     cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4]
+ */
+  __pyx_t_1 = PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_tuple__6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 20, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 20, __pyx_L1_error)
+  __pyx_t_4 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x2.rcbuffer->pybuffer, (PyObject*)__pyx_t_4, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_x2 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_x2.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 20, __pyx_L1_error)
+    } else {__pyx_pybuffernd_x2.diminfo[0].strides = __pyx_pybuffernd_x2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x2.diminfo[0].shape = __pyx_pybuffernd_x2.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_4 = 0;
+  __pyx_v_x2 = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "nms.pyx":21
+ *     cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ *     cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3]             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4]
+ * 
+ */
+  __pyx_t_1 = PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_tuple__8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 21, __pyx_L1_error)
+  __pyx_t_5 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_y2.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_y2 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_y2.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 21, __pyx_L1_error)
+    } else {__pyx_pybuffernd_y2.diminfo[0].strides = __pyx_pybuffernd_y2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_y2.diminfo[0].shape = __pyx_pybuffernd_y2.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_5 = 0;
+  __pyx_v_y2 = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "nms.pyx":22
+ *     cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3]
+ *     cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4]             # <<<<<<<<<<<<<<
+ * 
+ *     cdef np.ndarray[np.float32_t, ndim=1] areas = (x2 - x1 + 1) * (y2 - y1 + 1)
+ */
+  __pyx_t_1 = PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_tuple__10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 22, __pyx_L1_error)
+  __pyx_t_6 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_scores.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_scores = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_scores.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 22, __pyx_L1_error)
+    } else {__pyx_pybuffernd_scores.diminfo[0].strides = __pyx_pybuffernd_scores.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_scores.diminfo[0].shape = __pyx_pybuffernd_scores.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_6 = 0;
+  __pyx_v_scores = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "nms.pyx":24
+ *     cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4]
+ * 
+ *     cdef np.ndarray[np.float32_t, ndim=1] areas = (x2 - x1 + 1) * (y2 - y1 + 1)             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.int_t, ndim=1] order = scores.argsort()[::-1]
+ * 
+ */
+  __pyx_t_1 = PyNumber_Subtract(((PyObject *)__pyx_v_x2), ((PyObject *)__pyx_v_x1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 24, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_1, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 24, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyNumber_Subtract(((PyObject *)__pyx_v_y2), ((PyObject *)__pyx_v_y1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 24, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_8 = __Pyx_PyInt_AddObjC(__pyx_t_1, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 24, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyNumber_Multiply(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 24, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 24, __pyx_L1_error)
+  __pyx_t_9 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_areas.rcbuffer->pybuffer, (PyObject*)__pyx_t_9, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_areas = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_areas.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 24, __pyx_L1_error)
+    } else {__pyx_pybuffernd_areas.diminfo[0].strides = __pyx_pybuffernd_areas.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_areas.diminfo[0].shape = __pyx_pybuffernd_areas.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_9 = 0;
+  __pyx_v_areas = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "nms.pyx":25
+ * 
+ *     cdef np.ndarray[np.float32_t, ndim=1] areas = (x2 - x1 + 1) * (y2 - y1 + 1)
+ *     cdef np.ndarray[np.int_t, ndim=1] order = scores.argsort()[::-1]             # <<<<<<<<<<<<<<
+ * 
+ *     cdef int ndets = dets.shape[0]
+ */
+  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_scores), __pyx_n_s_argsort); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 25, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __pyx_t_7 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) {
+    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8);
+    if (likely(__pyx_t_7)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+      __Pyx_INCREF(__pyx_t_7);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_8, function);
+    }
+  }
+  if (__pyx_t_7) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  __pyx_t_8 = PyObject_GetItem(__pyx_t_1, __pyx_slice__11); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 25, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (!(likely(((__pyx_t_8) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_8, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 25, __pyx_L1_error)
+  __pyx_t_10 = ((PyArrayObject *)__pyx_t_8);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_order.rcbuffer->pybuffer, (PyObject*)__pyx_t_10, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_order = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_order.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 25, __pyx_L1_error)
+    } else {__pyx_pybuffernd_order.diminfo[0].strides = __pyx_pybuffernd_order.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_order.diminfo[0].shape = __pyx_pybuffernd_order.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_10 = 0;
+  __pyx_v_order = ((PyArrayObject *)__pyx_t_8);
+  __pyx_t_8 = 0;
+
+  /* "nms.pyx":27
+ *     cdef np.ndarray[np.int_t, ndim=1] order = scores.argsort()[::-1]
+ * 
+ *     cdef int ndets = dets.shape[0]             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.int_t, ndim=1] suppressed = \
+ *             np.zeros((ndets), dtype=np.int)
+ */
+  __pyx_v_ndets = (__pyx_v_dets->dimensions[0]);
+
+  /* "nms.pyx":29
+ *     cdef int ndets = dets.shape[0]
+ *     cdef np.ndarray[np.int_t, ndim=1] suppressed = \
+ *             np.zeros((ndets), dtype=np.int)             # <<<<<<<<<<<<<<
+ * 
+ *     # nominal indices
+ */
+  __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_ndets); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_GIVEREF(__pyx_t_8);
+  PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8);
+  __pyx_t_8 = 0;
+  __pyx_t_8 = PyDict_New(); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_11);
+  __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_int); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_12);
+  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+  if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_dtype, __pyx_t_12) < 0) __PYX_ERR(0, 29, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+  __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_12);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  if (!(likely(((__pyx_t_12) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_12, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 29, __pyx_L1_error)
+  __pyx_t_13 = ((PyArrayObject *)__pyx_t_12);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_suppressed.rcbuffer->pybuffer, (PyObject*)__pyx_t_13, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_suppressed = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_suppressed.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 28, __pyx_L1_error)
+    } else {__pyx_pybuffernd_suppressed.diminfo[0].strides = __pyx_pybuffernd_suppressed.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_suppressed.diminfo[0].shape = __pyx_pybuffernd_suppressed.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_13 = 0;
+  __pyx_v_suppressed = ((PyArrayObject *)__pyx_t_12);
+  __pyx_t_12 = 0;
+
+  /* "nms.pyx":42
+ *     cdef np.float32_t inter, ovr
+ * 
+ *     keep = []             # <<<<<<<<<<<<<<
+ *     for _i in range(ndets):
+ *         i = order[_i]
+ */
+  __pyx_t_12 = PyList_New(0); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_12);
+  __pyx_v_keep = ((PyObject*)__pyx_t_12);
+  __pyx_t_12 = 0;
+
+  /* "nms.pyx":43
+ * 
+ *     keep = []
+ *     for _i in range(ndets):             # <<<<<<<<<<<<<<
+ *         i = order[_i]
+ *         if suppressed[i] == 1:
+ */
+  __pyx_t_14 = __pyx_v_ndets;
+  for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) {
+    __pyx_v__i = __pyx_t_15;
+
+    /* "nms.pyx":44
+ *     keep = []
+ *     for _i in range(ndets):
+ *         i = order[_i]             # <<<<<<<<<<<<<<
+ *         if suppressed[i] == 1:
+ *             continue
+ */
+    __pyx_t_16 = __pyx_v__i;
+    __pyx_t_17 = -1;
+    if (__pyx_t_16 < 0) {
+      __pyx_t_16 += __pyx_pybuffernd_order.diminfo[0].shape;
+      if (unlikely(__pyx_t_16 < 0)) __pyx_t_17 = 0;
+    } else if (unlikely(__pyx_t_16 >= __pyx_pybuffernd_order.diminfo[0].shape)) __pyx_t_17 = 0;
+    if (unlikely(__pyx_t_17 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_17);
+      __PYX_ERR(0, 44, __pyx_L1_error)
+    }
+    __pyx_v_i = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int_t *, __pyx_pybuffernd_order.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_order.diminfo[0].strides));
+
+    /* "nms.pyx":45
+ *     for _i in range(ndets):
+ *         i = order[_i]
+ *         if suppressed[i] == 1:             # <<<<<<<<<<<<<<
+ *             continue
+ *         keep.append(i)
+ */
+    __pyx_t_18 = __pyx_v_i;
+    __pyx_t_17 = -1;
+    if (__pyx_t_18 < 0) {
+      __pyx_t_18 += __pyx_pybuffernd_suppressed.diminfo[0].shape;
+      if (unlikely(__pyx_t_18 < 0)) __pyx_t_17 = 0;
+    } else if (unlikely(__pyx_t_18 >= __pyx_pybuffernd_suppressed.diminfo[0].shape)) __pyx_t_17 = 0;
+    if (unlikely(__pyx_t_17 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_17);
+      __PYX_ERR(0, 45, __pyx_L1_error)
+    }
+    __pyx_t_19 = (((*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int_t *, __pyx_pybuffernd_suppressed.rcbuffer->pybuffer.buf, __pyx_t_18, __pyx_pybuffernd_suppressed.diminfo[0].strides)) == 1) != 0);
+    if (__pyx_t_19) {
+
+      /* "nms.pyx":46
+ *         i = order[_i]
+ *         if suppressed[i] == 1:
+ *             continue             # <<<<<<<<<<<<<<
+ *         keep.append(i)
+ *         ix1 = x1[i]
+ */
+      goto __pyx_L3_continue;
+
+      /* "nms.pyx":45
+ *     for _i in range(ndets):
+ *         i = order[_i]
+ *         if suppressed[i] == 1:             # <<<<<<<<<<<<<<
+ *             continue
+ *         keep.append(i)
+ */
+    }
+
+    /* "nms.pyx":47
+ *         if suppressed[i] == 1:
+ *             continue
+ *         keep.append(i)             # <<<<<<<<<<<<<<
+ *         ix1 = x1[i]
+ *         iy1 = y1[i]
+ */
+    __pyx_t_12 = __Pyx_PyInt_From_int(__pyx_v_i); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 47, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_12);
+    __pyx_t_20 = __Pyx_PyList_Append(__pyx_v_keep, __pyx_t_12); if (unlikely(__pyx_t_20 == -1)) __PYX_ERR(0, 47, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+
+    /* "nms.pyx":48
+ *             continue
+ *         keep.append(i)
+ *         ix1 = x1[i]             # <<<<<<<<<<<<<<
+ *         iy1 = y1[i]
+ *         ix2 = x2[i]
+ */
+    __pyx_t_21 = __pyx_v_i;
+    __pyx_t_17 = -1;
+    if (__pyx_t_21 < 0) {
+      __pyx_t_21 += __pyx_pybuffernd_x1.diminfo[0].shape;
+      if (unlikely(__pyx_t_21 < 0)) __pyx_t_17 = 0;
+    } else if (unlikely(__pyx_t_21 >= __pyx_pybuffernd_x1.diminfo[0].shape)) __pyx_t_17 = 0;
+    if (unlikely(__pyx_t_17 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_17);
+      __PYX_ERR(0, 48, __pyx_L1_error)
+    }
+    __pyx_v_ix1 = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_x1.rcbuffer->pybuffer.buf, __pyx_t_21, __pyx_pybuffernd_x1.diminfo[0].strides));
+
+    /* "nms.pyx":49
+ *         keep.append(i)
+ *         ix1 = x1[i]
+ *         iy1 = y1[i]             # <<<<<<<<<<<<<<
+ *         ix2 = x2[i]
+ *         iy2 = y2[i]
+ */
+    __pyx_t_22 = __pyx_v_i;
+    __pyx_t_17 = -1;
+    if (__pyx_t_22 < 0) {
+      __pyx_t_22 += __pyx_pybuffernd_y1.diminfo[0].shape;
+      if (unlikely(__pyx_t_22 < 0)) __pyx_t_17 = 0;
+    } else if (unlikely(__pyx_t_22 >= __pyx_pybuffernd_y1.diminfo[0].shape)) __pyx_t_17 = 0;
+    if (unlikely(__pyx_t_17 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_17);
+      __PYX_ERR(0, 49, __pyx_L1_error)
+    }
+    __pyx_v_iy1 = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_y1.rcbuffer->pybuffer.buf, __pyx_t_22, __pyx_pybuffernd_y1.diminfo[0].strides));
+
+    /* "nms.pyx":50
+ *         ix1 = x1[i]
+ *         iy1 = y1[i]
+ *         ix2 = x2[i]             # <<<<<<<<<<<<<<
+ *         iy2 = y2[i]
+ *         iarea = areas[i]
+ */
+    __pyx_t_23 = __pyx_v_i;
+    __pyx_t_17 = -1;
+    if (__pyx_t_23 < 0) {
+      __pyx_t_23 += __pyx_pybuffernd_x2.diminfo[0].shape;
+      if (unlikely(__pyx_t_23 < 0)) __pyx_t_17 = 0;
+    } else if (unlikely(__pyx_t_23 >= __pyx_pybuffernd_x2.diminfo[0].shape)) __pyx_t_17 = 0;
+    if (unlikely(__pyx_t_17 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_17);
+      __PYX_ERR(0, 50, __pyx_L1_error)
+    }
+    __pyx_v_ix2 = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_x2.rcbuffer->pybuffer.buf, __pyx_t_23, __pyx_pybuffernd_x2.diminfo[0].strides));
+
+    /* "nms.pyx":51
+ *         iy1 = y1[i]
+ *         ix2 = x2[i]
+ *         iy2 = y2[i]             # <<<<<<<<<<<<<<
+ *         iarea = areas[i]
+ *         for _j in range(_i + 1, ndets):
+ */
+    __pyx_t_24 = __pyx_v_i;
+    __pyx_t_17 = -1;
+    if (__pyx_t_24 < 0) {
+      __pyx_t_24 += __pyx_pybuffernd_y2.diminfo[0].shape;
+      if (unlikely(__pyx_t_24 < 0)) __pyx_t_17 = 0;
+    } else if (unlikely(__pyx_t_24 >= __pyx_pybuffernd_y2.diminfo[0].shape)) __pyx_t_17 = 0;
+    if (unlikely(__pyx_t_17 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_17);
+      __PYX_ERR(0, 51, __pyx_L1_error)
+    }
+    __pyx_v_iy2 = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_y2.rcbuffer->pybuffer.buf, __pyx_t_24, __pyx_pybuffernd_y2.diminfo[0].strides));
+
+    /* "nms.pyx":52
+ *         ix2 = x2[i]
+ *         iy2 = y2[i]
+ *         iarea = areas[i]             # <<<<<<<<<<<<<<
+ *         for _j in range(_i + 1, ndets):
+ *             j = order[_j]
+ */
+    __pyx_t_25 = __pyx_v_i;
+    __pyx_t_17 = -1;
+    if (__pyx_t_25 < 0) {
+      __pyx_t_25 += __pyx_pybuffernd_areas.diminfo[0].shape;
+      if (unlikely(__pyx_t_25 < 0)) __pyx_t_17 = 0;
+    } else if (unlikely(__pyx_t_25 >= __pyx_pybuffernd_areas.diminfo[0].shape)) __pyx_t_17 = 0;
+    if (unlikely(__pyx_t_17 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_17);
+      __PYX_ERR(0, 52, __pyx_L1_error)
+    }
+    __pyx_v_iarea = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_areas.rcbuffer->pybuffer.buf, __pyx_t_25, __pyx_pybuffernd_areas.diminfo[0].strides));
+
+    /* "nms.pyx":53
+ *         iy2 = y2[i]
+ *         iarea = areas[i]
+ *         for _j in range(_i + 1, ndets):             # <<<<<<<<<<<<<<
+ *             j = order[_j]
+ *             if suppressed[j] == 1:
+ */
+    __pyx_t_17 = __pyx_v_ndets;
+    for (__pyx_t_26 = (__pyx_v__i + 1); __pyx_t_26 < __pyx_t_17; __pyx_t_26+=1) {
+      __pyx_v__j = __pyx_t_26;
+
+      /* "nms.pyx":54
+ *         iarea = areas[i]
+ *         for _j in range(_i + 1, ndets):
+ *             j = order[_j]             # <<<<<<<<<<<<<<
+ *             if suppressed[j] == 1:
+ *                 continue
+ */
+      __pyx_t_27 = __pyx_v__j;
+      __pyx_t_28 = -1;
+      if (__pyx_t_27 < 0) {
+        __pyx_t_27 += __pyx_pybuffernd_order.diminfo[0].shape;
+        if (unlikely(__pyx_t_27 < 0)) __pyx_t_28 = 0;
+      } else if (unlikely(__pyx_t_27 >= __pyx_pybuffernd_order.diminfo[0].shape)) __pyx_t_28 = 0;
+      if (unlikely(__pyx_t_28 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_28);
+        __PYX_ERR(0, 54, __pyx_L1_error)
+      }
+      __pyx_v_j = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int_t *, __pyx_pybuffernd_order.rcbuffer->pybuffer.buf, __pyx_t_27, __pyx_pybuffernd_order.diminfo[0].strides));
+
+      /* "nms.pyx":55
+ *         for _j in range(_i + 1, ndets):
+ *             j = order[_j]
+ *             if suppressed[j] == 1:             # <<<<<<<<<<<<<<
+ *                 continue
+ *             xx1 = max(ix1, x1[j])
+ */
+      __pyx_t_29 = __pyx_v_j;
+      __pyx_t_28 = -1;
+      if (__pyx_t_29 < 0) {
+        __pyx_t_29 += __pyx_pybuffernd_suppressed.diminfo[0].shape;
+        if (unlikely(__pyx_t_29 < 0)) __pyx_t_28 = 0;
+      } else if (unlikely(__pyx_t_29 >= __pyx_pybuffernd_suppressed.diminfo[0].shape)) __pyx_t_28 = 0;
+      if (unlikely(__pyx_t_28 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_28);
+        __PYX_ERR(0, 55, __pyx_L1_error)
+      }
+      __pyx_t_19 = (((*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int_t *, __pyx_pybuffernd_suppressed.rcbuffer->pybuffer.buf, __pyx_t_29, __pyx_pybuffernd_suppressed.diminfo[0].strides)) == 1) != 0);
+      if (__pyx_t_19) {
+
+        /* "nms.pyx":56
+ *             j = order[_j]
+ *             if suppressed[j] == 1:
+ *                 continue             # <<<<<<<<<<<<<<
+ *             xx1 = max(ix1, x1[j])
+ *             yy1 = max(iy1, y1[j])
+ */
+        goto __pyx_L6_continue;
+
+        /* "nms.pyx":55
+ *         for _j in range(_i + 1, ndets):
+ *             j = order[_j]
+ *             if suppressed[j] == 1:             # <<<<<<<<<<<<<<
+ *                 continue
+ *             xx1 = max(ix1, x1[j])
+ */
+      }
+
+      /* "nms.pyx":57
+ *             if suppressed[j] == 1:
+ *                 continue
+ *             xx1 = max(ix1, x1[j])             # <<<<<<<<<<<<<<
+ *             yy1 = max(iy1, y1[j])
+ *             xx2 = min(ix2, x2[j])
+ */
+      __pyx_t_30 = __pyx_v_j;
+      __pyx_t_28 = -1;
+      if (__pyx_t_30 < 0) {
+        __pyx_t_30 += __pyx_pybuffernd_x1.diminfo[0].shape;
+        if (unlikely(__pyx_t_30 < 0)) __pyx_t_28 = 0;
+      } else if (unlikely(__pyx_t_30 >= __pyx_pybuffernd_x1.diminfo[0].shape)) __pyx_t_28 = 0;
+      if (unlikely(__pyx_t_28 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_28);
+        __PYX_ERR(0, 57, __pyx_L1_error)
+      }
+      __pyx_v_xx1 = __pyx_f_10cython_nms_max(__pyx_v_ix1, (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_x1.rcbuffer->pybuffer.buf, __pyx_t_30, __pyx_pybuffernd_x1.diminfo[0].strides)));
+
+      /* "nms.pyx":58
+ *                 continue
+ *             xx1 = max(ix1, x1[j])
+ *             yy1 = max(iy1, y1[j])             # <<<<<<<<<<<<<<
+ *             xx2 = min(ix2, x2[j])
+ *             yy2 = min(iy2, y2[j])
+ */
+      __pyx_t_31 = __pyx_v_j;
+      __pyx_t_28 = -1;
+      if (__pyx_t_31 < 0) {
+        __pyx_t_31 += __pyx_pybuffernd_y1.diminfo[0].shape;
+        if (unlikely(__pyx_t_31 < 0)) __pyx_t_28 = 0;
+      } else if (unlikely(__pyx_t_31 >= __pyx_pybuffernd_y1.diminfo[0].shape)) __pyx_t_28 = 0;
+      if (unlikely(__pyx_t_28 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_28);
+        __PYX_ERR(0, 58, __pyx_L1_error)
+      }
+      __pyx_v_yy1 = __pyx_f_10cython_nms_max(__pyx_v_iy1, (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_y1.rcbuffer->pybuffer.buf, __pyx_t_31, __pyx_pybuffernd_y1.diminfo[0].strides)));
+
+      /* "nms.pyx":59
+ *             xx1 = max(ix1, x1[j])
+ *             yy1 = max(iy1, y1[j])
+ *             xx2 = min(ix2, x2[j])             # <<<<<<<<<<<<<<
+ *             yy2 = min(iy2, y2[j])
+ *             w = max(0.0, xx2 - xx1 + 1)
+ */
+      __pyx_t_32 = __pyx_v_j;
+      __pyx_t_28 = -1;
+      if (__pyx_t_32 < 0) {
+        __pyx_t_32 += __pyx_pybuffernd_x2.diminfo[0].shape;
+        if (unlikely(__pyx_t_32 < 0)) __pyx_t_28 = 0;
+      } else if (unlikely(__pyx_t_32 >= __pyx_pybuffernd_x2.diminfo[0].shape)) __pyx_t_28 = 0;
+      if (unlikely(__pyx_t_28 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_28);
+        __PYX_ERR(0, 59, __pyx_L1_error)
+      }
+      __pyx_v_xx2 = __pyx_f_10cython_nms_min(__pyx_v_ix2, (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_x2.rcbuffer->pybuffer.buf, __pyx_t_32, __pyx_pybuffernd_x2.diminfo[0].strides)));
+
+      /* "nms.pyx":60
+ *             yy1 = max(iy1, y1[j])
+ *             xx2 = min(ix2, x2[j])
+ *             yy2 = min(iy2, y2[j])             # <<<<<<<<<<<<<<
+ *             w = max(0.0, xx2 - xx1 + 1)
+ *             h = max(0.0, yy2 - yy1 + 1)
+ */
+      __pyx_t_33 = __pyx_v_j;
+      __pyx_t_28 = -1;
+      if (__pyx_t_33 < 0) {
+        __pyx_t_33 += __pyx_pybuffernd_y2.diminfo[0].shape;
+        if (unlikely(__pyx_t_33 < 0)) __pyx_t_28 = 0;
+      } else if (unlikely(__pyx_t_33 >= __pyx_pybuffernd_y2.diminfo[0].shape)) __pyx_t_28 = 0;
+      if (unlikely(__pyx_t_28 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_28);
+        __PYX_ERR(0, 60, __pyx_L1_error)
+      }
+      __pyx_v_yy2 = __pyx_f_10cython_nms_min(__pyx_v_iy2, (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_y2.rcbuffer->pybuffer.buf, __pyx_t_33, __pyx_pybuffernd_y2.diminfo[0].strides)));
+
+      /* "nms.pyx":61
+ *             xx2 = min(ix2, x2[j])
+ *             yy2 = min(iy2, y2[j])
+ *             w = max(0.0, xx2 - xx1 + 1)             # <<<<<<<<<<<<<<
+ *             h = max(0.0, yy2 - yy1 + 1)
+ *             inter = w * h
+ */
+      __pyx_v_w = __pyx_f_10cython_nms_max(0.0, ((__pyx_v_xx2 - __pyx_v_xx1) + 1.0));
+
+      /* "nms.pyx":62
+ *             yy2 = min(iy2, y2[j])
+ *             w = max(0.0, xx2 - xx1 + 1)
+ *             h = max(0.0, yy2 - yy1 + 1)             # <<<<<<<<<<<<<<
+ *             inter = w * h
+ *             ovr = inter / (iarea + areas[j] - inter)
+ */
+      __pyx_v_h = __pyx_f_10cython_nms_max(0.0, ((__pyx_v_yy2 - __pyx_v_yy1) + 1.0));
+
+      /* "nms.pyx":63
+ *             w = max(0.0, xx2 - xx1 + 1)
+ *             h = max(0.0, yy2 - yy1 + 1)
+ *             inter = w * h             # <<<<<<<<<<<<<<
+ *             ovr = inter / (iarea + areas[j] - inter)
+ *             if ovr >= thresh:
+ */
+      __pyx_v_inter = (__pyx_v_w * __pyx_v_h);
+
+      /* "nms.pyx":64
+ *             h = max(0.0, yy2 - yy1 + 1)
+ *             inter = w * h
+ *             ovr = inter / (iarea + areas[j] - inter)             # <<<<<<<<<<<<<<
+ *             if ovr >= thresh:
+ *                 suppressed[j] = 1
+ */
+      __pyx_t_34 = __pyx_v_j;
+      __pyx_t_28 = -1;
+      if (__pyx_t_34 < 0) {
+        __pyx_t_34 += __pyx_pybuffernd_areas.diminfo[0].shape;
+        if (unlikely(__pyx_t_34 < 0)) __pyx_t_28 = 0;
+      } else if (unlikely(__pyx_t_34 >= __pyx_pybuffernd_areas.diminfo[0].shape)) __pyx_t_28 = 0;
+      if (unlikely(__pyx_t_28 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_28);
+        __PYX_ERR(0, 64, __pyx_L1_error)
+      }
+      __pyx_t_35 = ((__pyx_v_iarea + (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_areas.rcbuffer->pybuffer.buf, __pyx_t_34, __pyx_pybuffernd_areas.diminfo[0].strides))) - __pyx_v_inter);
+      if (unlikely(__pyx_t_35 == 0)) {
+        PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+        __PYX_ERR(0, 64, __pyx_L1_error)
+      }
+      __pyx_v_ovr = (__pyx_v_inter / __pyx_t_35);
+
+      /* "nms.pyx":65
+ *             inter = w * h
+ *             ovr = inter / (iarea + areas[j] - inter)
+ *             if ovr >= thresh:             # <<<<<<<<<<<<<<
+ *                 suppressed[j] = 1
+ * 
+ */
+      __pyx_t_12 = PyFloat_FromDouble(__pyx_v_ovr); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 65, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_12);
+      __pyx_t_8 = PyObject_RichCompare(__pyx_t_12, __pyx_v_thresh, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 65, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+      __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_19 < 0)) __PYX_ERR(0, 65, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      if (__pyx_t_19) {
+
+        /* "nms.pyx":66
+ *             ovr = inter / (iarea + areas[j] - inter)
+ *             if ovr >= thresh:
+ *                 suppressed[j] = 1             # <<<<<<<<<<<<<<
+ * 
+ *     return keep
+ */
+        __pyx_t_36 = __pyx_v_j;
+        __pyx_t_28 = -1;
+        if (__pyx_t_36 < 0) {
+          __pyx_t_36 += __pyx_pybuffernd_suppressed.diminfo[0].shape;
+          if (unlikely(__pyx_t_36 < 0)) __pyx_t_28 = 0;
+        } else if (unlikely(__pyx_t_36 >= __pyx_pybuffernd_suppressed.diminfo[0].shape)) __pyx_t_28 = 0;
+        if (unlikely(__pyx_t_28 != -1)) {
+          __Pyx_RaiseBufferIndexError(__pyx_t_28);
+          __PYX_ERR(0, 66, __pyx_L1_error)
+        }
+        *__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int_t *, __pyx_pybuffernd_suppressed.rcbuffer->pybuffer.buf, __pyx_t_36, __pyx_pybuffernd_suppressed.diminfo[0].strides) = 1;
+
+        /* "nms.pyx":65
+ *             inter = w * h
+ *             ovr = inter / (iarea + areas[j] - inter)
+ *             if ovr >= thresh:             # <<<<<<<<<<<<<<
+ *                 suppressed[j] = 1
+ * 
+ */
+      }
+      __pyx_L6_continue:;
+    }
+    __pyx_L3_continue:;
+  }
+
+  /* "nms.pyx":68
+ *                 suppressed[j] = 1
+ * 
+ *     return keep             # <<<<<<<<<<<<<<
+ * 
+ * def nms_new(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_keep);
+  __pyx_r = __pyx_v_keep;
+  goto __pyx_L0;
+
+  /* "nms.pyx":17
+ *     return a if a <= b else b
+ * 
+ * def nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_areas.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_dets.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_order.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_scores.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_suppressed.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x1.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x2.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_y1.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_y2.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("cython_nms.nms", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_areas.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_dets.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_order.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_scores.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_suppressed.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x1.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x2.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_y1.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_y2.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_x1);
+  __Pyx_XDECREF((PyObject *)__pyx_v_y1);
+  __Pyx_XDECREF((PyObject *)__pyx_v_x2);
+  __Pyx_XDECREF((PyObject *)__pyx_v_y2);
+  __Pyx_XDECREF((PyObject *)__pyx_v_scores);
+  __Pyx_XDECREF((PyObject *)__pyx_v_areas);
+  __Pyx_XDECREF((PyObject *)__pyx_v_order);
+  __Pyx_XDECREF((PyObject *)__pyx_v_suppressed);
+  __Pyx_XDECREF(__pyx_v_keep);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "nms.pyx":70
+ *     return keep
+ * 
+ * def nms_new(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_10cython_nms_3nms_new(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_10cython_nms_3nms_new = {"nms_new", (PyCFunction)__pyx_pw_10cython_nms_3nms_new, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_10cython_nms_3nms_new(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyArrayObject *__pyx_v_dets = 0;
+  PyObject *__pyx_v_thresh = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("nms_new (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_dets,&__pyx_n_s_thresh,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_dets)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_thresh)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("nms_new", 1, 2, 2, 1); __PYX_ERR(0, 70, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "nms_new") < 0)) __PYX_ERR(0, 70, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_dets = ((PyArrayObject *)values[0]);
+    __pyx_v_thresh = ((PyObject*)values[1]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("nms_new", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 70, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("cython_nms.nms_new", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dets), __pyx_ptype_5numpy_ndarray, 1, "dets", 0))) __PYX_ERR(0, 70, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_thresh), (&PyFloat_Type), 1, "thresh", 1))) __PYX_ERR(0, 70, __pyx_L1_error)
+  __pyx_r = __pyx_pf_10cython_nms_2nms_new(__pyx_self, __pyx_v_dets, __pyx_v_thresh);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_10cython_nms_2nms_new(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_dets, PyObject *__pyx_v_thresh) {
+  PyArrayObject *__pyx_v_x1 = 0;
+  PyArrayObject *__pyx_v_y1 = 0;
+  PyArrayObject *__pyx_v_x2 = 0;
+  PyArrayObject *__pyx_v_y2 = 0;
+  PyArrayObject *__pyx_v_scores = 0;
+  PyArrayObject *__pyx_v_areas = 0;
+  PyArrayObject *__pyx_v_order = 0;
+  int __pyx_v_ndets;
+  PyArrayObject *__pyx_v_suppressed = 0;
+  int __pyx_v__i;
+  int __pyx_v__j;
+  int __pyx_v_i;
+  int __pyx_v_j;
+  __pyx_t_5numpy_float32_t __pyx_v_ix1;
+  __pyx_t_5numpy_float32_t __pyx_v_iy1;
+  __pyx_t_5numpy_float32_t __pyx_v_ix2;
+  __pyx_t_5numpy_float32_t __pyx_v_iy2;
+  __pyx_t_5numpy_float32_t __pyx_v_iarea;
+  __pyx_t_5numpy_float32_t __pyx_v_xx1;
+  __pyx_t_5numpy_float32_t __pyx_v_yy1;
+  __pyx_t_5numpy_float32_t __pyx_v_xx2;
+  __pyx_t_5numpy_float32_t __pyx_v_yy2;
+  __pyx_t_5numpy_float32_t __pyx_v_w;
+  __pyx_t_5numpy_float32_t __pyx_v_h;
+  __pyx_t_5numpy_float32_t __pyx_v_inter;
+  __pyx_t_5numpy_float32_t __pyx_v_ovr;
+  PyObject *__pyx_v_keep = NULL;
+  PyObject *__pyx_v_ovr1 = NULL;
+  PyObject *__pyx_v_ovr2 = NULL;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_areas;
+  __Pyx_Buffer __pyx_pybuffer_areas;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_dets;
+  __Pyx_Buffer __pyx_pybuffer_dets;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_order;
+  __Pyx_Buffer __pyx_pybuffer_order;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_scores;
+  __Pyx_Buffer __pyx_pybuffer_scores;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_suppressed;
+  __Pyx_Buffer __pyx_pybuffer_suppressed;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_x1;
+  __Pyx_Buffer __pyx_pybuffer_x1;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_x2;
+  __Pyx_Buffer __pyx_pybuffer_x2;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_y1;
+  __Pyx_Buffer __pyx_pybuffer_y1;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_y2;
+  __Pyx_Buffer __pyx_pybuffer_y2;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyArrayObject *__pyx_t_2 = NULL;
+  PyArrayObject *__pyx_t_3 = NULL;
+  PyArrayObject *__pyx_t_4 = NULL;
+  PyArrayObject *__pyx_t_5 = NULL;
+  PyArrayObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  PyArrayObject *__pyx_t_9 = NULL;
+  PyArrayObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyArrayObject *__pyx_t_13 = NULL;
+  int __pyx_t_14;
+  int __pyx_t_15;
+  Py_ssize_t __pyx_t_16;
+  int __pyx_t_17;
+  Py_ssize_t __pyx_t_18;
+  int __pyx_t_19;
+  int __pyx_t_20;
+  Py_ssize_t __pyx_t_21;
+  Py_ssize_t __pyx_t_22;
+  Py_ssize_t __pyx_t_23;
+  Py_ssize_t __pyx_t_24;
+  Py_ssize_t __pyx_t_25;
+  int __pyx_t_26;
+  Py_ssize_t __pyx_t_27;
+  int __pyx_t_28;
+  Py_ssize_t __pyx_t_29;
+  Py_ssize_t __pyx_t_30;
+  Py_ssize_t __pyx_t_31;
+  Py_ssize_t __pyx_t_32;
+  Py_ssize_t __pyx_t_33;
+  Py_ssize_t __pyx_t_34;
+  __pyx_t_5numpy_float32_t __pyx_t_35;
+  Py_ssize_t __pyx_t_36;
+  int __pyx_t_37;
+  Py_ssize_t __pyx_t_38;
+  __Pyx_RefNannySetupContext("nms_new", 0);
+  __pyx_pybuffer_x1.pybuffer.buf = NULL;
+  __pyx_pybuffer_x1.refcount = 0;
+  __pyx_pybuffernd_x1.data = NULL;
+  __pyx_pybuffernd_x1.rcbuffer = &__pyx_pybuffer_x1;
+  __pyx_pybuffer_y1.pybuffer.buf = NULL;
+  __pyx_pybuffer_y1.refcount = 0;
+  __pyx_pybuffernd_y1.data = NULL;
+  __pyx_pybuffernd_y1.rcbuffer = &__pyx_pybuffer_y1;
+  __pyx_pybuffer_x2.pybuffer.buf = NULL;
+  __pyx_pybuffer_x2.refcount = 0;
+  __pyx_pybuffernd_x2.data = NULL;
+  __pyx_pybuffernd_x2.rcbuffer = &__pyx_pybuffer_x2;
+  __pyx_pybuffer_y2.pybuffer.buf = NULL;
+  __pyx_pybuffer_y2.refcount = 0;
+  __pyx_pybuffernd_y2.data = NULL;
+  __pyx_pybuffernd_y2.rcbuffer = &__pyx_pybuffer_y2;
+  __pyx_pybuffer_scores.pybuffer.buf = NULL;
+  __pyx_pybuffer_scores.refcount = 0;
+  __pyx_pybuffernd_scores.data = NULL;
+  __pyx_pybuffernd_scores.rcbuffer = &__pyx_pybuffer_scores;
+  __pyx_pybuffer_areas.pybuffer.buf = NULL;
+  __pyx_pybuffer_areas.refcount = 0;
+  __pyx_pybuffernd_areas.data = NULL;
+  __pyx_pybuffernd_areas.rcbuffer = &__pyx_pybuffer_areas;
+  __pyx_pybuffer_order.pybuffer.buf = NULL;
+  __pyx_pybuffer_order.refcount = 0;
+  __pyx_pybuffernd_order.data = NULL;
+  __pyx_pybuffernd_order.rcbuffer = &__pyx_pybuffer_order;
+  __pyx_pybuffer_suppressed.pybuffer.buf = NULL;
+  __pyx_pybuffer_suppressed.refcount = 0;
+  __pyx_pybuffernd_suppressed.data = NULL;
+  __pyx_pybuffernd_suppressed.rcbuffer = &__pyx_pybuffer_suppressed;
+  __pyx_pybuffer_dets.pybuffer.buf = NULL;
+  __pyx_pybuffer_dets.refcount = 0;
+  __pyx_pybuffernd_dets.data = NULL;
+  __pyx_pybuffernd_dets.rcbuffer = &__pyx_pybuffer_dets;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_dets.rcbuffer->pybuffer, (PyObject*)__pyx_v_dets, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 70, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_dets.diminfo[0].strides = __pyx_pybuffernd_dets.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_dets.diminfo[0].shape = __pyx_pybuffernd_dets.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_dets.diminfo[1].strides = __pyx_pybuffernd_dets.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_dets.diminfo[1].shape = __pyx_pybuffernd_dets.rcbuffer->pybuffer.shape[1];
+
+  /* "nms.pyx":71
+ * 
+ * def nms_new(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):
+ *     cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ *     cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]
+ */
+  __pyx_t_1 = PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_tuple__13); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 71, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 71, __pyx_L1_error)
+  __pyx_t_2 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x1.rcbuffer->pybuffer, (PyObject*)__pyx_t_2, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_x1 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_x1.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 71, __pyx_L1_error)
+    } else {__pyx_pybuffernd_x1.diminfo[0].strides = __pyx_pybuffernd_x1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x1.diminfo[0].shape = __pyx_pybuffernd_x1.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_2 = 0;
+  __pyx_v_x1 = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "nms.pyx":72
+ * def nms_new(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):
+ *     cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3]
+ */
+  __pyx_t_1 = PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_tuple__15); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 72, __pyx_L1_error)
+  __pyx_t_3 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_y1.rcbuffer->pybuffer, (PyObject*)__pyx_t_3, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_y1 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_y1.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 72, __pyx_L1_error)
+    } else {__pyx_pybuffernd_y1.diminfo[0].strides = __pyx_pybuffernd_y1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_y1.diminfo[0].shape = __pyx_pybuffernd_y1.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_3 = 0;
+  __pyx_v_y1 = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "nms.pyx":73
+ *     cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ *     cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3]
+ *     cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4]
+ */
+  __pyx_t_1 = PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_tuple__17); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 73, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 73, __pyx_L1_error)
+  __pyx_t_4 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x2.rcbuffer->pybuffer, (PyObject*)__pyx_t_4, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_x2 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_x2.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 73, __pyx_L1_error)
+    } else {__pyx_pybuffernd_x2.diminfo[0].strides = __pyx_pybuffernd_x2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x2.diminfo[0].shape = __pyx_pybuffernd_x2.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_4 = 0;
+  __pyx_v_x2 = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "nms.pyx":74
+ *     cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ *     cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3]             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4]
+ * 
+ */
+  __pyx_t_1 = PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_tuple__19); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 74, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 74, __pyx_L1_error)
+  __pyx_t_5 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_y2.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_y2 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_y2.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 74, __pyx_L1_error)
+    } else {__pyx_pybuffernd_y2.diminfo[0].strides = __pyx_pybuffernd_y2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_y2.diminfo[0].shape = __pyx_pybuffernd_y2.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_5 = 0;
+  __pyx_v_y2 = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "nms.pyx":75
+ *     cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3]
+ *     cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4]             # <<<<<<<<<<<<<<
+ * 
+ *     cdef np.ndarray[np.float32_t, ndim=1] areas = (x2 - x1 + 1) * (y2 - y1 + 1)
+ */
+  __pyx_t_1 = PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_tuple__21); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 75, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 75, __pyx_L1_error)
+  __pyx_t_6 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_scores.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_scores = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_scores.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 75, __pyx_L1_error)
+    } else {__pyx_pybuffernd_scores.diminfo[0].strides = __pyx_pybuffernd_scores.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_scores.diminfo[0].shape = __pyx_pybuffernd_scores.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_6 = 0;
+  __pyx_v_scores = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "nms.pyx":77
+ *     cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4]
+ * 
+ *     cdef np.ndarray[np.float32_t, ndim=1] areas = (x2 - x1 + 1) * (y2 - y1 + 1)             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.int_t, ndim=1] order = scores.argsort()[::-1]
+ * 
+ */
+  __pyx_t_1 = PyNumber_Subtract(((PyObject *)__pyx_v_x2), ((PyObject *)__pyx_v_x1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_1, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 77, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyNumber_Subtract(((PyObject *)__pyx_v_y2), ((PyObject *)__pyx_v_y1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_8 = __Pyx_PyInt_AddObjC(__pyx_t_1, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 77, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyNumber_Multiply(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 77, __pyx_L1_error)
+  __pyx_t_9 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_areas.rcbuffer->pybuffer, (PyObject*)__pyx_t_9, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_areas = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_areas.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 77, __pyx_L1_error)
+    } else {__pyx_pybuffernd_areas.diminfo[0].strides = __pyx_pybuffernd_areas.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_areas.diminfo[0].shape = __pyx_pybuffernd_areas.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_9 = 0;
+  __pyx_v_areas = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "nms.pyx":78
+ * 
+ *     cdef np.ndarray[np.float32_t, ndim=1] areas = (x2 - x1 + 1) * (y2 - y1 + 1)
+ *     cdef np.ndarray[np.int_t, ndim=1] order = scores.argsort()[::-1]             # <<<<<<<<<<<<<<
+ * 
+ *     cdef int ndets = dets.shape[0]
+ */
+  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_scores), __pyx_n_s_argsort); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __pyx_t_7 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) {
+    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8);
+    if (likely(__pyx_t_7)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+      __Pyx_INCREF(__pyx_t_7);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_8, function);
+    }
+  }
+  if (__pyx_t_7) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 78, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 78, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  __pyx_t_8 = PyObject_GetItem(__pyx_t_1, __pyx_slice__22); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (!(likely(((__pyx_t_8) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_8, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 78, __pyx_L1_error)
+  __pyx_t_10 = ((PyArrayObject *)__pyx_t_8);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_order.rcbuffer->pybuffer, (PyObject*)__pyx_t_10, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_order = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_order.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 78, __pyx_L1_error)
+    } else {__pyx_pybuffernd_order.diminfo[0].strides = __pyx_pybuffernd_order.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_order.diminfo[0].shape = __pyx_pybuffernd_order.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_10 = 0;
+  __pyx_v_order = ((PyArrayObject *)__pyx_t_8);
+  __pyx_t_8 = 0;
+
+  /* "nms.pyx":80
+ *     cdef np.ndarray[np.int_t, ndim=1] order = scores.argsort()[::-1]
+ * 
+ *     cdef int ndets = dets.shape[0]             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.int_t, ndim=1] suppressed = \
+ *             np.zeros((ndets), dtype=np.int)
+ */
+  __pyx_v_ndets = (__pyx_v_dets->dimensions[0]);
+
+  /* "nms.pyx":82
+ *     cdef int ndets = dets.shape[0]
+ *     cdef np.ndarray[np.int_t, ndim=1] suppressed = \
+ *             np.zeros((ndets), dtype=np.int)             # <<<<<<<<<<<<<<
+ * 
+ *     # nominal indices
+ */
+  __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_ndets); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_GIVEREF(__pyx_t_8);
+  PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8);
+  __pyx_t_8 = 0;
+  __pyx_t_8 = PyDict_New(); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_11);
+  __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_int); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_12);
+  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+  if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_dtype, __pyx_t_12) < 0) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+  __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_12);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  if (!(likely(((__pyx_t_12) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_12, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 82, __pyx_L1_error)
+  __pyx_t_13 = ((PyArrayObject *)__pyx_t_12);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_suppressed.rcbuffer->pybuffer, (PyObject*)__pyx_t_13, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_suppressed = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_suppressed.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 81, __pyx_L1_error)
+    } else {__pyx_pybuffernd_suppressed.diminfo[0].strides = __pyx_pybuffernd_suppressed.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_suppressed.diminfo[0].shape = __pyx_pybuffernd_suppressed.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_13 = 0;
+  __pyx_v_suppressed = ((PyArrayObject *)__pyx_t_12);
+  __pyx_t_12 = 0;
+
+  /* "nms.pyx":95
+ *     cdef np.float32_t inter, ovr
+ * 
+ *     keep = []             # <<<<<<<<<<<<<<
+ *     for _i in range(ndets):
+ *         i = order[_i]
+ */
+  __pyx_t_12 = PyList_New(0); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 95, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_12);
+  __pyx_v_keep = ((PyObject*)__pyx_t_12);
+  __pyx_t_12 = 0;
+
+  /* "nms.pyx":96
+ * 
+ *     keep = []
+ *     for _i in range(ndets):             # <<<<<<<<<<<<<<
+ *         i = order[_i]
+ *         if suppressed[i] == 1:
+ */
+  __pyx_t_14 = __pyx_v_ndets;
+  for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) {
+    __pyx_v__i = __pyx_t_15;
+
+    /* "nms.pyx":97
+ *     keep = []
+ *     for _i in range(ndets):
+ *         i = order[_i]             # <<<<<<<<<<<<<<
+ *         if suppressed[i] == 1:
+ *             continue
+ */
+    __pyx_t_16 = __pyx_v__i;
+    __pyx_t_17 = -1;
+    if (__pyx_t_16 < 0) {
+      __pyx_t_16 += __pyx_pybuffernd_order.diminfo[0].shape;
+      if (unlikely(__pyx_t_16 < 0)) __pyx_t_17 = 0;
+    } else if (unlikely(__pyx_t_16 >= __pyx_pybuffernd_order.diminfo[0].shape)) __pyx_t_17 = 0;
+    if (unlikely(__pyx_t_17 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_17);
+      __PYX_ERR(0, 97, __pyx_L1_error)
+    }
+    __pyx_v_i = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int_t *, __pyx_pybuffernd_order.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_order.diminfo[0].strides));
+
+    /* "nms.pyx":98
+ *     for _i in range(ndets):
+ *         i = order[_i]
+ *         if suppressed[i] == 1:             # <<<<<<<<<<<<<<
+ *             continue
+ *         keep.append(i)
+ */
+    __pyx_t_18 = __pyx_v_i;
+    __pyx_t_17 = -1;
+    if (__pyx_t_18 < 0) {
+      __pyx_t_18 += __pyx_pybuffernd_suppressed.diminfo[0].shape;
+      if (unlikely(__pyx_t_18 < 0)) __pyx_t_17 = 0;
+    } else if (unlikely(__pyx_t_18 >= __pyx_pybuffernd_suppressed.diminfo[0].shape)) __pyx_t_17 = 0;
+    if (unlikely(__pyx_t_17 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_17);
+      __PYX_ERR(0, 98, __pyx_L1_error)
+    }
+    __pyx_t_19 = (((*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int_t *, __pyx_pybuffernd_suppressed.rcbuffer->pybuffer.buf, __pyx_t_18, __pyx_pybuffernd_suppressed.diminfo[0].strides)) == 1) != 0);
+    if (__pyx_t_19) {
+
+      /* "nms.pyx":99
+ *         i = order[_i]
+ *         if suppressed[i] == 1:
+ *             continue             # <<<<<<<<<<<<<<
+ *         keep.append(i)
+ *         ix1 = x1[i]
+ */
+      goto __pyx_L3_continue;
+
+      /* "nms.pyx":98
+ *     for _i in range(ndets):
+ *         i = order[_i]
+ *         if suppressed[i] == 1:             # <<<<<<<<<<<<<<
+ *             continue
+ *         keep.append(i)
+ */
+    }
+
+    /* "nms.pyx":100
+ *         if suppressed[i] == 1:
+ *             continue
+ *         keep.append(i)             # <<<<<<<<<<<<<<
+ *         ix1 = x1[i]
+ *         iy1 = y1[i]
+ */
+    __pyx_t_12 = __Pyx_PyInt_From_int(__pyx_v_i); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 100, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_12);
+    __pyx_t_20 = __Pyx_PyList_Append(__pyx_v_keep, __pyx_t_12); if (unlikely(__pyx_t_20 == -1)) __PYX_ERR(0, 100, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+
+    /* "nms.pyx":101
+ *             continue
+ *         keep.append(i)
+ *         ix1 = x1[i]             # <<<<<<<<<<<<<<
+ *         iy1 = y1[i]
+ *         ix2 = x2[i]
+ */
+    __pyx_t_21 = __pyx_v_i;
+    __pyx_t_17 = -1;
+    if (__pyx_t_21 < 0) {
+      __pyx_t_21 += __pyx_pybuffernd_x1.diminfo[0].shape;
+      if (unlikely(__pyx_t_21 < 0)) __pyx_t_17 = 0;
+    } else if (unlikely(__pyx_t_21 >= __pyx_pybuffernd_x1.diminfo[0].shape)) __pyx_t_17 = 0;
+    if (unlikely(__pyx_t_17 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_17);
+      __PYX_ERR(0, 101, __pyx_L1_error)
+    }
+    __pyx_v_ix1 = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_x1.rcbuffer->pybuffer.buf, __pyx_t_21, __pyx_pybuffernd_x1.diminfo[0].strides));
+
+    /* "nms.pyx":102
+ *         keep.append(i)
+ *         ix1 = x1[i]
+ *         iy1 = y1[i]             # <<<<<<<<<<<<<<
+ *         ix2 = x2[i]
+ *         iy2 = y2[i]
+ */
+    __pyx_t_22 = __pyx_v_i;
+    __pyx_t_17 = -1;
+    if (__pyx_t_22 < 0) {
+      __pyx_t_22 += __pyx_pybuffernd_y1.diminfo[0].shape;
+      if (unlikely(__pyx_t_22 < 0)) __pyx_t_17 = 0;
+    } else if (unlikely(__pyx_t_22 >= __pyx_pybuffernd_y1.diminfo[0].shape)) __pyx_t_17 = 0;
+    if (unlikely(__pyx_t_17 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_17);
+      __PYX_ERR(0, 102, __pyx_L1_error)
+    }
+    __pyx_v_iy1 = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_y1.rcbuffer->pybuffer.buf, __pyx_t_22, __pyx_pybuffernd_y1.diminfo[0].strides));
+
+    /* "nms.pyx":103
+ *         ix1 = x1[i]
+ *         iy1 = y1[i]
+ *         ix2 = x2[i]             # <<<<<<<<<<<<<<
+ *         iy2 = y2[i]
+ *         iarea = areas[i]
+ */
+    __pyx_t_23 = __pyx_v_i;
+    __pyx_t_17 = -1;
+    if (__pyx_t_23 < 0) {
+      __pyx_t_23 += __pyx_pybuffernd_x2.diminfo[0].shape;
+      if (unlikely(__pyx_t_23 < 0)) __pyx_t_17 = 0;
+    } else if (unlikely(__pyx_t_23 >= __pyx_pybuffernd_x2.diminfo[0].shape)) __pyx_t_17 = 0;
+    if (unlikely(__pyx_t_17 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_17);
+      __PYX_ERR(0, 103, __pyx_L1_error)
+    }
+    __pyx_v_ix2 = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_x2.rcbuffer->pybuffer.buf, __pyx_t_23, __pyx_pybuffernd_x2.diminfo[0].strides));
+
+    /* "nms.pyx":104
+ *         iy1 = y1[i]
+ *         ix2 = x2[i]
+ *         iy2 = y2[i]             # <<<<<<<<<<<<<<
+ *         iarea = areas[i]
+ *         for _j in range(_i + 1, ndets):
+ */
+    __pyx_t_24 = __pyx_v_i;
+    __pyx_t_17 = -1;
+    if (__pyx_t_24 < 0) {
+      __pyx_t_24 += __pyx_pybuffernd_y2.diminfo[0].shape;
+      if (unlikely(__pyx_t_24 < 0)) __pyx_t_17 = 0;
+    } else if (unlikely(__pyx_t_24 >= __pyx_pybuffernd_y2.diminfo[0].shape)) __pyx_t_17 = 0;
+    if (unlikely(__pyx_t_17 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_17);
+      __PYX_ERR(0, 104, __pyx_L1_error)
+    }
+    __pyx_v_iy2 = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_y2.rcbuffer->pybuffer.buf, __pyx_t_24, __pyx_pybuffernd_y2.diminfo[0].strides));
+
+    /* "nms.pyx":105
+ *         ix2 = x2[i]
+ *         iy2 = y2[i]
+ *         iarea = areas[i]             # <<<<<<<<<<<<<<
+ *         for _j in range(_i + 1, ndets):
+ *             j = order[_j]
+ */
+    __pyx_t_25 = __pyx_v_i;
+    __pyx_t_17 = -1;
+    if (__pyx_t_25 < 0) {
+      __pyx_t_25 += __pyx_pybuffernd_areas.diminfo[0].shape;
+      if (unlikely(__pyx_t_25 < 0)) __pyx_t_17 = 0;
+    } else if (unlikely(__pyx_t_25 >= __pyx_pybuffernd_areas.diminfo[0].shape)) __pyx_t_17 = 0;
+    if (unlikely(__pyx_t_17 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_17);
+      __PYX_ERR(0, 105, __pyx_L1_error)
+    }
+    __pyx_v_iarea = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_areas.rcbuffer->pybuffer.buf, __pyx_t_25, __pyx_pybuffernd_areas.diminfo[0].strides));
+
+    /* "nms.pyx":106
+ *         iy2 = y2[i]
+ *         iarea = areas[i]
+ *         for _j in range(_i + 1, ndets):             # <<<<<<<<<<<<<<
+ *             j = order[_j]
+ *             if suppressed[j] == 1:
+ */
+    __pyx_t_17 = __pyx_v_ndets;
+    for (__pyx_t_26 = (__pyx_v__i + 1); __pyx_t_26 < __pyx_t_17; __pyx_t_26+=1) {
+      __pyx_v__j = __pyx_t_26;
+
+      /* "nms.pyx":107
+ *         iarea = areas[i]
+ *         for _j in range(_i + 1, ndets):
+ *             j = order[_j]             # <<<<<<<<<<<<<<
+ *             if suppressed[j] == 1:
+ *                 continue
+ */
+      __pyx_t_27 = __pyx_v__j;
+      __pyx_t_28 = -1;
+      if (__pyx_t_27 < 0) {
+        __pyx_t_27 += __pyx_pybuffernd_order.diminfo[0].shape;
+        if (unlikely(__pyx_t_27 < 0)) __pyx_t_28 = 0;
+      } else if (unlikely(__pyx_t_27 >= __pyx_pybuffernd_order.diminfo[0].shape)) __pyx_t_28 = 0;
+      if (unlikely(__pyx_t_28 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_28);
+        __PYX_ERR(0, 107, __pyx_L1_error)
+      }
+      __pyx_v_j = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int_t *, __pyx_pybuffernd_order.rcbuffer->pybuffer.buf, __pyx_t_27, __pyx_pybuffernd_order.diminfo[0].strides));
+
+      /* "nms.pyx":108
+ *         for _j in range(_i + 1, ndets):
+ *             j = order[_j]
+ *             if suppressed[j] == 1:             # <<<<<<<<<<<<<<
+ *                 continue
+ *             xx1 = max(ix1, x1[j])
+ */
+      __pyx_t_29 = __pyx_v_j;
+      __pyx_t_28 = -1;
+      if (__pyx_t_29 < 0) {
+        __pyx_t_29 += __pyx_pybuffernd_suppressed.diminfo[0].shape;
+        if (unlikely(__pyx_t_29 < 0)) __pyx_t_28 = 0;
+      } else if (unlikely(__pyx_t_29 >= __pyx_pybuffernd_suppressed.diminfo[0].shape)) __pyx_t_28 = 0;
+      if (unlikely(__pyx_t_28 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_28);
+        __PYX_ERR(0, 108, __pyx_L1_error)
+      }
+      __pyx_t_19 = (((*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int_t *, __pyx_pybuffernd_suppressed.rcbuffer->pybuffer.buf, __pyx_t_29, __pyx_pybuffernd_suppressed.diminfo[0].strides)) == 1) != 0);
+      if (__pyx_t_19) {
+
+        /* "nms.pyx":109
+ *             j = order[_j]
+ *             if suppressed[j] == 1:
+ *                 continue             # <<<<<<<<<<<<<<
+ *             xx1 = max(ix1, x1[j])
+ *             yy1 = max(iy1, y1[j])
+ */
+        goto __pyx_L6_continue;
+
+        /* "nms.pyx":108
+ *         for _j in range(_i + 1, ndets):
+ *             j = order[_j]
+ *             if suppressed[j] == 1:             # <<<<<<<<<<<<<<
+ *                 continue
+ *             xx1 = max(ix1, x1[j])
+ */
+      }
+
+      /* "nms.pyx":110
+ *             if suppressed[j] == 1:
+ *                 continue
+ *             xx1 = max(ix1, x1[j])             # <<<<<<<<<<<<<<
+ *             yy1 = max(iy1, y1[j])
+ *             xx2 = min(ix2, x2[j])
+ */
+      __pyx_t_30 = __pyx_v_j;
+      __pyx_t_28 = -1;
+      if (__pyx_t_30 < 0) {
+        __pyx_t_30 += __pyx_pybuffernd_x1.diminfo[0].shape;
+        if (unlikely(__pyx_t_30 < 0)) __pyx_t_28 = 0;
+      } else if (unlikely(__pyx_t_30 >= __pyx_pybuffernd_x1.diminfo[0].shape)) __pyx_t_28 = 0;
+      if (unlikely(__pyx_t_28 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_28);
+        __PYX_ERR(0, 110, __pyx_L1_error)
+      }
+      __pyx_v_xx1 = __pyx_f_10cython_nms_max(__pyx_v_ix1, (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_x1.rcbuffer->pybuffer.buf, __pyx_t_30, __pyx_pybuffernd_x1.diminfo[0].strides)));
+
+      /* "nms.pyx":111
+ *                 continue
+ *             xx1 = max(ix1, x1[j])
+ *             yy1 = max(iy1, y1[j])             # <<<<<<<<<<<<<<
+ *             xx2 = min(ix2, x2[j])
+ *             yy2 = min(iy2, y2[j])
+ */
+      __pyx_t_31 = __pyx_v_j;
+      __pyx_t_28 = -1;
+      if (__pyx_t_31 < 0) {
+        __pyx_t_31 += __pyx_pybuffernd_y1.diminfo[0].shape;
+        if (unlikely(__pyx_t_31 < 0)) __pyx_t_28 = 0;
+      } else if (unlikely(__pyx_t_31 >= __pyx_pybuffernd_y1.diminfo[0].shape)) __pyx_t_28 = 0;
+      if (unlikely(__pyx_t_28 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_28);
+        __PYX_ERR(0, 111, __pyx_L1_error)
+      }
+      __pyx_v_yy1 = __pyx_f_10cython_nms_max(__pyx_v_iy1, (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_y1.rcbuffer->pybuffer.buf, __pyx_t_31, __pyx_pybuffernd_y1.diminfo[0].strides)));
+
+      /* "nms.pyx":112
+ *             xx1 = max(ix1, x1[j])
+ *             yy1 = max(iy1, y1[j])
+ *             xx2 = min(ix2, x2[j])             # <<<<<<<<<<<<<<
+ *             yy2 = min(iy2, y2[j])
+ *             w = max(0.0, xx2 - xx1 + 1)
+ */
+      __pyx_t_32 = __pyx_v_j;
+      __pyx_t_28 = -1;
+      if (__pyx_t_32 < 0) {
+        __pyx_t_32 += __pyx_pybuffernd_x2.diminfo[0].shape;
+        if (unlikely(__pyx_t_32 < 0)) __pyx_t_28 = 0;
+      } else if (unlikely(__pyx_t_32 >= __pyx_pybuffernd_x2.diminfo[0].shape)) __pyx_t_28 = 0;
+      if (unlikely(__pyx_t_28 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_28);
+        __PYX_ERR(0, 112, __pyx_L1_error)
+      }
+      __pyx_v_xx2 = __pyx_f_10cython_nms_min(__pyx_v_ix2, (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_x2.rcbuffer->pybuffer.buf, __pyx_t_32, __pyx_pybuffernd_x2.diminfo[0].strides)));
+
+      /* "nms.pyx":113
+ *             yy1 = max(iy1, y1[j])
+ *             xx2 = min(ix2, x2[j])
+ *             yy2 = min(iy2, y2[j])             # <<<<<<<<<<<<<<
+ *             w = max(0.0, xx2 - xx1 + 1)
+ *             h = max(0.0, yy2 - yy1 + 1)
+ */
+      __pyx_t_33 = __pyx_v_j;
+      __pyx_t_28 = -1;
+      if (__pyx_t_33 < 0) {
+        __pyx_t_33 += __pyx_pybuffernd_y2.diminfo[0].shape;
+        if (unlikely(__pyx_t_33 < 0)) __pyx_t_28 = 0;
+      } else if (unlikely(__pyx_t_33 >= __pyx_pybuffernd_y2.diminfo[0].shape)) __pyx_t_28 = 0;
+      if (unlikely(__pyx_t_28 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_28);
+        __PYX_ERR(0, 113, __pyx_L1_error)
+      }
+      __pyx_v_yy2 = __pyx_f_10cython_nms_min(__pyx_v_iy2, (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_y2.rcbuffer->pybuffer.buf, __pyx_t_33, __pyx_pybuffernd_y2.diminfo[0].strides)));
+
+      /* "nms.pyx":114
+ *             xx2 = min(ix2, x2[j])
+ *             yy2 = min(iy2, y2[j])
+ *             w = max(0.0, xx2 - xx1 + 1)             # <<<<<<<<<<<<<<
+ *             h = max(0.0, yy2 - yy1 + 1)
+ *             inter = w * h
+ */
+      __pyx_v_w = __pyx_f_10cython_nms_max(0.0, ((__pyx_v_xx2 - __pyx_v_xx1) + 1.0));
+
+      /* "nms.pyx":115
+ *             yy2 = min(iy2, y2[j])
+ *             w = max(0.0, xx2 - xx1 + 1)
+ *             h = max(0.0, yy2 - yy1 + 1)             # <<<<<<<<<<<<<<
+ *             inter = w * h
+ *             ovr = inter / (iarea + areas[j] - inter)
+ */
+      __pyx_v_h = __pyx_f_10cython_nms_max(0.0, ((__pyx_v_yy2 - __pyx_v_yy1) + 1.0));
+
+      /* "nms.pyx":116
+ *             w = max(0.0, xx2 - xx1 + 1)
+ *             h = max(0.0, yy2 - yy1 + 1)
+ *             inter = w * h             # <<<<<<<<<<<<<<
+ *             ovr = inter / (iarea + areas[j] - inter)
+ *             ovr1 = inter / iarea
+ */
+      __pyx_v_inter = (__pyx_v_w * __pyx_v_h);
+
+      /* "nms.pyx":117
+ *             h = max(0.0, yy2 - yy1 + 1)
+ *             inter = w * h
+ *             ovr = inter / (iarea + areas[j] - inter)             # <<<<<<<<<<<<<<
+ *             ovr1 = inter / iarea
+ *             ovr2 = inter / areas[j]
+ */
+      __pyx_t_34 = __pyx_v_j;
+      __pyx_t_28 = -1;
+      if (__pyx_t_34 < 0) {
+        __pyx_t_34 += __pyx_pybuffernd_areas.diminfo[0].shape;
+        if (unlikely(__pyx_t_34 < 0)) __pyx_t_28 = 0;
+      } else if (unlikely(__pyx_t_34 >= __pyx_pybuffernd_areas.diminfo[0].shape)) __pyx_t_28 = 0;
+      if (unlikely(__pyx_t_28 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_28);
+        __PYX_ERR(0, 117, __pyx_L1_error)
+      }
+      __pyx_t_35 = ((__pyx_v_iarea + (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_areas.rcbuffer->pybuffer.buf, __pyx_t_34, __pyx_pybuffernd_areas.diminfo[0].strides))) - __pyx_v_inter);
+      if (unlikely(__pyx_t_35 == 0)) {
+        PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+        __PYX_ERR(0, 117, __pyx_L1_error)
+      }
+      __pyx_v_ovr = (__pyx_v_inter / __pyx_t_35);
+
+      /* "nms.pyx":118
+ *             inter = w * h
+ *             ovr = inter / (iarea + areas[j] - inter)
+ *             ovr1 = inter / iarea             # <<<<<<<<<<<<<<
+ *             ovr2 = inter / areas[j]
+ *             if ovr >= thresh or ovr1 > 0.95 or ovr2 > 0.95:
+ */
+      if (unlikely(__pyx_v_iarea == 0)) {
+        PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+        __PYX_ERR(0, 118, __pyx_L1_error)
+      }
+      __pyx_t_12 = PyFloat_FromDouble((__pyx_v_inter / __pyx_v_iarea)); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 118, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_12);
+      __Pyx_XDECREF_SET(__pyx_v_ovr1, __pyx_t_12);
+      __pyx_t_12 = 0;
+
+      /* "nms.pyx":119
+ *             ovr = inter / (iarea + areas[j] - inter)
+ *             ovr1 = inter / iarea
+ *             ovr2 = inter / areas[j]             # <<<<<<<<<<<<<<
+ *             if ovr >= thresh or ovr1 > 0.95 or ovr2 > 0.95:
+ *                 suppressed[j] = 1
+ */
+      __pyx_t_36 = __pyx_v_j;
+      __pyx_t_28 = -1;
+      if (__pyx_t_36 < 0) {
+        __pyx_t_36 += __pyx_pybuffernd_areas.diminfo[0].shape;
+        if (unlikely(__pyx_t_36 < 0)) __pyx_t_28 = 0;
+      } else if (unlikely(__pyx_t_36 >= __pyx_pybuffernd_areas.diminfo[0].shape)) __pyx_t_28 = 0;
+      if (unlikely(__pyx_t_28 != -1)) {
+        __Pyx_RaiseBufferIndexError(__pyx_t_28);
+        __PYX_ERR(0, 119, __pyx_L1_error)
+      }
+      __pyx_t_35 = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_areas.rcbuffer->pybuffer.buf, __pyx_t_36, __pyx_pybuffernd_areas.diminfo[0].strides));
+      if (unlikely(__pyx_t_35 == 0)) {
+        PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+        __PYX_ERR(0, 119, __pyx_L1_error)
+      }
+      __pyx_t_12 = PyFloat_FromDouble((__pyx_v_inter / __pyx_t_35)); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 119, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_12);
+      __Pyx_XDECREF_SET(__pyx_v_ovr2, __pyx_t_12);
+      __pyx_t_12 = 0;
+
+      /* "nms.pyx":120
+ *             ovr1 = inter / iarea
+ *             ovr2 = inter / areas[j]
+ *             if ovr >= thresh or ovr1 > 0.95 or ovr2 > 0.95:             # <<<<<<<<<<<<<<
+ *                 suppressed[j] = 1
+ * 
+ */
+      __pyx_t_12 = PyFloat_FromDouble(__pyx_v_ovr); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 120, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_12);
+      __pyx_t_8 = PyObject_RichCompare(__pyx_t_12, __pyx_v_thresh, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 120, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+      __pyx_t_37 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_37 < 0)) __PYX_ERR(0, 120, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      if (!__pyx_t_37) {
+      } else {
+        __pyx_t_19 = __pyx_t_37;
+        goto __pyx_L10_bool_binop_done;
+      }
+      __pyx_t_8 = PyObject_RichCompare(__pyx_v_ovr1, __pyx_float_0_95, Py_GT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 120, __pyx_L1_error)
+      __pyx_t_37 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_37 < 0)) __PYX_ERR(0, 120, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      if (!__pyx_t_37) {
+      } else {
+        __pyx_t_19 = __pyx_t_37;
+        goto __pyx_L10_bool_binop_done;
+      }
+      __pyx_t_8 = PyObject_RichCompare(__pyx_v_ovr2, __pyx_float_0_95, Py_GT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 120, __pyx_L1_error)
+      __pyx_t_37 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_37 < 0)) __PYX_ERR(0, 120, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __pyx_t_19 = __pyx_t_37;
+      __pyx_L10_bool_binop_done:;
+      if (__pyx_t_19) {
+
+        /* "nms.pyx":121
+ *             ovr2 = inter / areas[j]
+ *             if ovr >= thresh or ovr1 > 0.95 or ovr2 > 0.95:
+ *                 suppressed[j] = 1             # <<<<<<<<<<<<<<
+ * 
+ *     return keep
+ */
+        __pyx_t_38 = __pyx_v_j;
+        __pyx_t_28 = -1;
+        if (__pyx_t_38 < 0) {
+          __pyx_t_38 += __pyx_pybuffernd_suppressed.diminfo[0].shape;
+          if (unlikely(__pyx_t_38 < 0)) __pyx_t_28 = 0;
+        } else if (unlikely(__pyx_t_38 >= __pyx_pybuffernd_suppressed.diminfo[0].shape)) __pyx_t_28 = 0;
+        if (unlikely(__pyx_t_28 != -1)) {
+          __Pyx_RaiseBufferIndexError(__pyx_t_28);
+          __PYX_ERR(0, 121, __pyx_L1_error)
+        }
+        *__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int_t *, __pyx_pybuffernd_suppressed.rcbuffer->pybuffer.buf, __pyx_t_38, __pyx_pybuffernd_suppressed.diminfo[0].strides) = 1;
+
+        /* "nms.pyx":120
+ *             ovr1 = inter / iarea
+ *             ovr2 = inter / areas[j]
+ *             if ovr >= thresh or ovr1 > 0.95 or ovr2 > 0.95:             # <<<<<<<<<<<<<<
+ *                 suppressed[j] = 1
+ * 
+ */
+      }
+      __pyx_L6_continue:;
+    }
+    __pyx_L3_continue:;
+  }
+
+  /* "nms.pyx":123
+ *                 suppressed[j] = 1
+ * 
+ *     return keep             # <<<<<<<<<<<<<<
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_keep);
+  __pyx_r = __pyx_v_keep;
+  goto __pyx_L0;
+
+  /* "nms.pyx":70
+ *     return keep
+ * 
+ * def nms_new(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_areas.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_dets.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_order.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_scores.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_suppressed.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x1.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x2.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_y1.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_y2.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("cython_nms.nms_new", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_areas.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_dets.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_order.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_scores.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_suppressed.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x1.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x2.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_y1.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_y2.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_x1);
+  __Pyx_XDECREF((PyObject *)__pyx_v_y1);
+  __Pyx_XDECREF((PyObject *)__pyx_v_x2);
+  __Pyx_XDECREF((PyObject *)__pyx_v_y2);
+  __Pyx_XDECREF((PyObject *)__pyx_v_scores);
+  __Pyx_XDECREF((PyObject *)__pyx_v_areas);
+  __Pyx_XDECREF((PyObject *)__pyx_v_order);
+  __Pyx_XDECREF((PyObject *)__pyx_v_suppressed);
+  __Pyx_XDECREF(__pyx_v_keep);
+  __Pyx_XDECREF(__pyx_v_ovr1);
+  __Pyx_XDECREF(__pyx_v_ovr2);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":197
+ *         # experimental exception made for __getbuffer__ and __releasebuffer__
+ *         # -- the details of this may change.
+ *         def __getbuffer__(ndarray self, Py_buffer* info, int flags):             # <<<<<<<<<<<<<<
+ *             # This implementation of getbuffer is geared towards Cython
+ *             # requirements, and does not yet fullfill the PEP.
+ */
+
+/* Python wrapper */
+static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
+static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
+  int __pyx_v_copy_shape;
+  int __pyx_v_i;
+  int __pyx_v_ndim;
+  int __pyx_v_endian_detector;
+  int __pyx_v_little_endian;
+  int __pyx_v_t;
+  char *__pyx_v_f;
+  PyArray_Descr *__pyx_v_descr = 0;
+  int __pyx_v_offset;
+  int __pyx_v_hasfields;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  char *__pyx_t_7;
+  __Pyx_RefNannySetupContext("__getbuffer__", 0);
+  if (__pyx_v_info != NULL) {
+    __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(__pyx_v_info->obj);
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":203
+ *             # of flags
+ * 
+ *             if info == NULL: return             # <<<<<<<<<<<<<<
+ * 
+ *             cdef int copy_shape, i, ndim
+ */
+  __pyx_t_1 = ((__pyx_v_info == NULL) != 0);
+  if (__pyx_t_1) {
+    __pyx_r = 0;
+    goto __pyx_L0;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":206
+ * 
+ *             cdef int copy_shape, i, ndim
+ *             cdef int endian_detector = 1             # <<<<<<<<<<<<<<
+ *             cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)
+ * 
+ */
+  __pyx_v_endian_detector = 1;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":207
+ *             cdef int copy_shape, i, ndim
+ *             cdef int endian_detector = 1
+ *             cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)             # <<<<<<<<<<<<<<
+ * 
+ *             ndim = PyArray_NDIM(self)
+ */
+  __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":209
+ *             cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)
+ * 
+ *             ndim = PyArray_NDIM(self)             # <<<<<<<<<<<<<<
+ * 
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ */
+  __pyx_v_ndim = PyArray_NDIM(__pyx_v_self);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":211
+ *             ndim = PyArray_NDIM(self)
+ * 
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
+ *                 copy_shape = 1
+ *             else:
+ */
+  __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":212
+ * 
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ *                 copy_shape = 1             # <<<<<<<<<<<<<<
+ *             else:
+ *                 copy_shape = 0
+ */
+    __pyx_v_copy_shape = 1;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":211
+ *             ndim = PyArray_NDIM(self)
+ * 
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
+ *                 copy_shape = 1
+ *             else:
+ */
+    goto __pyx_L4;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":214
+ *                 copy_shape = 1
+ *             else:
+ *                 copy_shape = 0             # <<<<<<<<<<<<<<
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
+ */
+  /*else*/ {
+    __pyx_v_copy_shape = 0;
+  }
+  __pyx_L4:;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216
+ *                 copy_shape = 0
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ */
+  __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L6_bool_binop_done;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":217
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):             # <<<<<<<<<<<<<<
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ * 
+ */
+  __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_C_CONTIGUOUS) != 0)) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L6_bool_binop_done:;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216
+ *                 copy_shape = 0
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ */
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":218
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")             # <<<<<<<<<<<<<<
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 218, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(1, 218, __pyx_L1_error)
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216
+ *                 copy_shape = 0
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ */
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ */
+  __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L9_bool_binop_done;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":221
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):             # <<<<<<<<<<<<<<
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ * 
+ */
+  __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_F_CONTIGUOUS) != 0)) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L9_bool_binop_done:;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ */
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":222
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")             # <<<<<<<<<<<<<<
+ * 
+ *             info.buf = PyArray_DATA(self)
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 222, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(1, 222, __pyx_L1_error)
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ */
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":224
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ * 
+ *             info.buf = PyArray_DATA(self)             # <<<<<<<<<<<<<<
+ *             info.ndim = ndim
+ *             if copy_shape:
+ */
+  __pyx_v_info->buf = PyArray_DATA(__pyx_v_self);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":225
+ * 
+ *             info.buf = PyArray_DATA(self)
+ *             info.ndim = ndim             # <<<<<<<<<<<<<<
+ *             if copy_shape:
+ *                 # Allocate new buffer for strides and shape info.
+ */
+  __pyx_v_info->ndim = __pyx_v_ndim;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":226
+ *             info.buf = PyArray_DATA(self)
+ *             info.ndim = ndim
+ *             if copy_shape:             # <<<<<<<<<<<<<<
+ *                 # Allocate new buffer for strides and shape info.
+ *                 # This is allocated as one block, strides first.
+ */
+  __pyx_t_1 = (__pyx_v_copy_shape != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":229
+ *                 # Allocate new buffer for strides and shape info.
+ *                 # This is allocated as one block, strides first.
+ *                 info.strides = <Py_ssize_t*>stdlib.malloc(sizeof(Py_ssize_t) * <size_t>ndim * 2)             # <<<<<<<<<<<<<<
+ *                 info.shape = info.strides + ndim
+ *                 for i in range(ndim):
+ */
+    __pyx_v_info->strides = ((Py_ssize_t *)malloc((((sizeof(Py_ssize_t)) * ((size_t)__pyx_v_ndim)) * 2)));
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":230
+ *                 # This is allocated as one block, strides first.
+ *                 info.strides = <Py_ssize_t*>stdlib.malloc(sizeof(Py_ssize_t) * <size_t>ndim * 2)
+ *                 info.shape = info.strides + ndim             # <<<<<<<<<<<<<<
+ *                 for i in range(ndim):
+ *                     info.strides[i] = PyArray_STRIDES(self)[i]
+ */
+    __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim);
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":231
+ *                 info.strides = <Py_ssize_t*>stdlib.malloc(sizeof(Py_ssize_t) * <size_t>ndim * 2)
+ *                 info.shape = info.strides + ndim
+ *                 for i in range(ndim):             # <<<<<<<<<<<<<<
+ *                     info.strides[i] = PyArray_STRIDES(self)[i]
+ *                     info.shape[i] = PyArray_DIMS(self)[i]
+ */
+    __pyx_t_4 = __pyx_v_ndim;
+    for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
+      __pyx_v_i = __pyx_t_5;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":232
+ *                 info.shape = info.strides + ndim
+ *                 for i in range(ndim):
+ *                     info.strides[i] = PyArray_STRIDES(self)[i]             # <<<<<<<<<<<<<<
+ *                     info.shape[i] = PyArray_DIMS(self)[i]
+ *             else:
+ */
+      (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]);
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":233
+ *                 for i in range(ndim):
+ *                     info.strides[i] = PyArray_STRIDES(self)[i]
+ *                     info.shape[i] = PyArray_DIMS(self)[i]             # <<<<<<<<<<<<<<
+ *             else:
+ *                 info.strides = <Py_ssize_t*>PyArray_STRIDES(self)
+ */
+      (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]);
+    }
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":226
+ *             info.buf = PyArray_DATA(self)
+ *             info.ndim = ndim
+ *             if copy_shape:             # <<<<<<<<<<<<<<
+ *                 # Allocate new buffer for strides and shape info.
+ *                 # This is allocated as one block, strides first.
+ */
+    goto __pyx_L11;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":235
+ *                     info.shape[i] = PyArray_DIMS(self)[i]
+ *             else:
+ *                 info.strides = <Py_ssize_t*>PyArray_STRIDES(self)             # <<<<<<<<<<<<<<
+ *                 info.shape = <Py_ssize_t*>PyArray_DIMS(self)
+ *             info.suboffsets = NULL
+ */
+  /*else*/ {
+    __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self));
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":236
+ *             else:
+ *                 info.strides = <Py_ssize_t*>PyArray_STRIDES(self)
+ *                 info.shape = <Py_ssize_t*>PyArray_DIMS(self)             # <<<<<<<<<<<<<<
+ *             info.suboffsets = NULL
+ *             info.itemsize = PyArray_ITEMSIZE(self)
+ */
+    __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self));
+  }
+  __pyx_L11:;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":237
+ *                 info.strides = <Py_ssize_t*>PyArray_STRIDES(self)
+ *                 info.shape = <Py_ssize_t*>PyArray_DIMS(self)
+ *             info.suboffsets = NULL             # <<<<<<<<<<<<<<
+ *             info.itemsize = PyArray_ITEMSIZE(self)
+ *             info.readonly = not PyArray_ISWRITEABLE(self)
+ */
+  __pyx_v_info->suboffsets = NULL;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":238
+ *                 info.shape = <Py_ssize_t*>PyArray_DIMS(self)
+ *             info.suboffsets = NULL
+ *             info.itemsize = PyArray_ITEMSIZE(self)             # <<<<<<<<<<<<<<
+ *             info.readonly = not PyArray_ISWRITEABLE(self)
+ * 
+ */
+  __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":239
+ *             info.suboffsets = NULL
+ *             info.itemsize = PyArray_ITEMSIZE(self)
+ *             info.readonly = not PyArray_ISWRITEABLE(self)             # <<<<<<<<<<<<<<
+ * 
+ *             cdef int t
+ */
+  __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0));
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":242
+ * 
+ *             cdef int t
+ *             cdef char* f = NULL             # <<<<<<<<<<<<<<
+ *             cdef dtype descr = self.descr
+ *             cdef int offset
+ */
+  __pyx_v_f = NULL;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":243
+ *             cdef int t
+ *             cdef char* f = NULL
+ *             cdef dtype descr = self.descr             # <<<<<<<<<<<<<<
+ *             cdef int offset
+ * 
+ */
+  __pyx_t_3 = ((PyObject *)__pyx_v_self->descr);
+  __Pyx_INCREF(__pyx_t_3);
+  __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":246
+ *             cdef int offset
+ * 
+ *             cdef bint hasfields = PyDataType_HASFIELDS(descr)             # <<<<<<<<<<<<<<
+ * 
+ *             if not hasfields and not copy_shape:
+ */
+  __pyx_v_hasfields = PyDataType_HASFIELDS(__pyx_v_descr);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":248
+ *             cdef bint hasfields = PyDataType_HASFIELDS(descr)
+ * 
+ *             if not hasfields and not copy_shape:             # <<<<<<<<<<<<<<
+ *                 # do not call releasebuffer
+ *                 info.obj = None
+ */
+  __pyx_t_2 = ((!(__pyx_v_hasfields != 0)) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L15_bool_binop_done;
+  }
+  __pyx_t_2 = ((!(__pyx_v_copy_shape != 0)) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L15_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":250
+ *             if not hasfields and not copy_shape:
+ *                 # do not call releasebuffer
+ *                 info.obj = None             # <<<<<<<<<<<<<<
+ *             else:
+ *                 # need to call releasebuffer
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __Pyx_GOTREF(__pyx_v_info->obj);
+    __Pyx_DECREF(__pyx_v_info->obj);
+    __pyx_v_info->obj = Py_None;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":248
+ *             cdef bint hasfields = PyDataType_HASFIELDS(descr)
+ * 
+ *             if not hasfields and not copy_shape:             # <<<<<<<<<<<<<<
+ *                 # do not call releasebuffer
+ *                 info.obj = None
+ */
+    goto __pyx_L14;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":253
+ *             else:
+ *                 # need to call releasebuffer
+ *                 info.obj = self             # <<<<<<<<<<<<<<
+ * 
+ *             if not hasfields:
+ */
+  /*else*/ {
+    __Pyx_INCREF(((PyObject *)__pyx_v_self));
+    __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+    __Pyx_GOTREF(__pyx_v_info->obj);
+    __Pyx_DECREF(__pyx_v_info->obj);
+    __pyx_v_info->obj = ((PyObject *)__pyx_v_self);
+  }
+  __pyx_L14:;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":255
+ *                 info.obj = self
+ * 
+ *             if not hasfields:             # <<<<<<<<<<<<<<
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ */
+  __pyx_t_1 = ((!(__pyx_v_hasfields != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":256
+ * 
+ *             if not hasfields:
+ *                 t = descr.type_num             # <<<<<<<<<<<<<<
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ */
+    __pyx_t_4 = __pyx_v_descr->type_num;
+    __pyx_v_t = __pyx_t_4;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257
+ *             if not hasfields:
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")
+ */
+    __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0);
+    if (!__pyx_t_2) {
+      goto __pyx_L20_next_or;
+    } else {
+    }
+    __pyx_t_2 = (__pyx_v_little_endian != 0);
+    if (!__pyx_t_2) {
+    } else {
+      __pyx_t_1 = __pyx_t_2;
+      goto __pyx_L19_bool_binop_done;
+    }
+    __pyx_L20_next_or:;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":258
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ *                     (descr.byteorder == c'<' and not little_endian)):             # <<<<<<<<<<<<<<
+ *                     raise ValueError(u"Non-native byte order not supported")
+ *                 if   t == NPY_BYTE:        f = "b"
+ */
+    __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0);
+    if (__pyx_t_2) {
+    } else {
+      __pyx_t_1 = __pyx_t_2;
+      goto __pyx_L19_bool_binop_done;
+    }
+    __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0);
+    __pyx_t_1 = __pyx_t_2;
+    __pyx_L19_bool_binop_done:;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257
+ *             if not hasfields:
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")
+ */
+    if (__pyx_t_1) {
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":259
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
+ *                 if   t == NPY_BYTE:        f = "b"
+ *                 elif t == NPY_UBYTE:       f = "B"
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 259, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(1, 259, __pyx_L1_error)
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257
+ *             if not hasfields:
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")
+ */
+    }
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":260
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")
+ *                 if   t == NPY_BYTE:        f = "b"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_UBYTE:       f = "B"
+ *                 elif t == NPY_SHORT:       f = "h"
+ */
+    switch (__pyx_v_t) {
+      case NPY_BYTE:
+      __pyx_v_f = ((char *)"b");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":261
+ *                     raise ValueError(u"Non-native byte order not supported")
+ *                 if   t == NPY_BYTE:        f = "b"
+ *                 elif t == NPY_UBYTE:       f = "B"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_SHORT:       f = "h"
+ *                 elif t == NPY_USHORT:      f = "H"
+ */
+      case NPY_UBYTE:
+      __pyx_v_f = ((char *)"B");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":262
+ *                 if   t == NPY_BYTE:        f = "b"
+ *                 elif t == NPY_UBYTE:       f = "B"
+ *                 elif t == NPY_SHORT:       f = "h"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_USHORT:      f = "H"
+ *                 elif t == NPY_INT:         f = "i"
+ */
+      case NPY_SHORT:
+      __pyx_v_f = ((char *)"h");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":263
+ *                 elif t == NPY_UBYTE:       f = "B"
+ *                 elif t == NPY_SHORT:       f = "h"
+ *                 elif t == NPY_USHORT:      f = "H"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_INT:         f = "i"
+ *                 elif t == NPY_UINT:        f = "I"
+ */
+      case NPY_USHORT:
+      __pyx_v_f = ((char *)"H");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":264
+ *                 elif t == NPY_SHORT:       f = "h"
+ *                 elif t == NPY_USHORT:      f = "H"
+ *                 elif t == NPY_INT:         f = "i"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_UINT:        f = "I"
+ *                 elif t == NPY_LONG:        f = "l"
+ */
+      case NPY_INT:
+      __pyx_v_f = ((char *)"i");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":265
+ *                 elif t == NPY_USHORT:      f = "H"
+ *                 elif t == NPY_INT:         f = "i"
+ *                 elif t == NPY_UINT:        f = "I"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_LONG:        f = "l"
+ *                 elif t == NPY_ULONG:       f = "L"
+ */
+      case NPY_UINT:
+      __pyx_v_f = ((char *)"I");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":266
+ *                 elif t == NPY_INT:         f = "i"
+ *                 elif t == NPY_UINT:        f = "I"
+ *                 elif t == NPY_LONG:        f = "l"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_ULONG:       f = "L"
+ *                 elif t == NPY_LONGLONG:    f = "q"
+ */
+      case NPY_LONG:
+      __pyx_v_f = ((char *)"l");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":267
+ *                 elif t == NPY_UINT:        f = "I"
+ *                 elif t == NPY_LONG:        f = "l"
+ *                 elif t == NPY_ULONG:       f = "L"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_LONGLONG:    f = "q"
+ *                 elif t == NPY_ULONGLONG:   f = "Q"
+ */
+      case NPY_ULONG:
+      __pyx_v_f = ((char *)"L");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":268
+ *                 elif t == NPY_LONG:        f = "l"
+ *                 elif t == NPY_ULONG:       f = "L"
+ *                 elif t == NPY_LONGLONG:    f = "q"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_ULONGLONG:   f = "Q"
+ *                 elif t == NPY_FLOAT:       f = "f"
+ */
+      case NPY_LONGLONG:
+      __pyx_v_f = ((char *)"q");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":269
+ *                 elif t == NPY_ULONG:       f = "L"
+ *                 elif t == NPY_LONGLONG:    f = "q"
+ *                 elif t == NPY_ULONGLONG:   f = "Q"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_FLOAT:       f = "f"
+ *                 elif t == NPY_DOUBLE:      f = "d"
+ */
+      case NPY_ULONGLONG:
+      __pyx_v_f = ((char *)"Q");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":270
+ *                 elif t == NPY_LONGLONG:    f = "q"
+ *                 elif t == NPY_ULONGLONG:   f = "Q"
+ *                 elif t == NPY_FLOAT:       f = "f"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_DOUBLE:      f = "d"
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"
+ */
+      case NPY_FLOAT:
+      __pyx_v_f = ((char *)"f");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":271
+ *                 elif t == NPY_ULONGLONG:   f = "Q"
+ *                 elif t == NPY_FLOAT:       f = "f"
+ *                 elif t == NPY_DOUBLE:      f = "d"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"
+ *                 elif t == NPY_CFLOAT:      f = "Zf"
+ */
+      case NPY_DOUBLE:
+      __pyx_v_f = ((char *)"d");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":272
+ *                 elif t == NPY_FLOAT:       f = "f"
+ *                 elif t == NPY_DOUBLE:      f = "d"
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_CFLOAT:      f = "Zf"
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"
+ */
+      case NPY_LONGDOUBLE:
+      __pyx_v_f = ((char *)"g");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":273
+ *                 elif t == NPY_DOUBLE:      f = "d"
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"
+ *                 elif t == NPY_CFLOAT:      f = "Zf"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"
+ *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
+ */
+      case NPY_CFLOAT:
+      __pyx_v_f = ((char *)"Zf");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":274
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"
+ *                 elif t == NPY_CFLOAT:      f = "Zf"
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
+ *                 elif t == NPY_OBJECT:      f = "O"
+ */
+      case NPY_CDOUBLE:
+      __pyx_v_f = ((char *)"Zd");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":275
+ *                 elif t == NPY_CFLOAT:      f = "Zf"
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"
+ *                 elif t == NPY_CLONGDOUBLE: f = "Zg"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_OBJECT:      f = "O"
+ *                 else:
+ */
+      case NPY_CLONGDOUBLE:
+      __pyx_v_f = ((char *)"Zg");
+      break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":276
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"
+ *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
+ *                 elif t == NPY_OBJECT:      f = "O"             # <<<<<<<<<<<<<<
+ *                 else:
+ *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ */
+      case NPY_OBJECT:
+      __pyx_v_f = ((char *)"O");
+      break;
+      default:
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":278
+ *                 elif t == NPY_OBJECT:      f = "O"
+ *                 else:
+ *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)             # <<<<<<<<<<<<<<
+ *                 info.format = f
+ *                 return
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 278, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_6 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 278, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 278, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_GIVEREF(__pyx_t_6);
+      PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6);
+      __pyx_t_6 = 0;
+      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 278, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_Raise(__pyx_t_6, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __PYX_ERR(1, 278, __pyx_L1_error)
+      break;
+    }
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":279
+ *                 else:
+ *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ *                 info.format = f             # <<<<<<<<<<<<<<
+ *                 return
+ *             else:
+ */
+    __pyx_v_info->format = __pyx_v_f;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":280
+ *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ *                 info.format = f
+ *                 return             # <<<<<<<<<<<<<<
+ *             else:
+ *                 info.format = <char*>stdlib.malloc(_buffer_format_string_len)
+ */
+    __pyx_r = 0;
+    goto __pyx_L0;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":255
+ *                 info.obj = self
+ * 
+ *             if not hasfields:             # <<<<<<<<<<<<<<
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ */
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":282
+ *                 return
+ *             else:
+ *                 info.format = <char*>stdlib.malloc(_buffer_format_string_len)             # <<<<<<<<<<<<<<
+ *                 info.format[0] = c'^' # Native data types, manual alignment
+ *                 offset = 0
+ */
+  /*else*/ {
+    __pyx_v_info->format = ((char *)malloc(0xFF));
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":283
+ *             else:
+ *                 info.format = <char*>stdlib.malloc(_buffer_format_string_len)
+ *                 info.format[0] = c'^' # Native data types, manual alignment             # <<<<<<<<<<<<<<
+ *                 offset = 0
+ *                 f = _util_dtypestring(descr, info.format + 1,
+ */
+    (__pyx_v_info->format[0]) = '^';
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":284
+ *                 info.format = <char*>stdlib.malloc(_buffer_format_string_len)
+ *                 info.format[0] = c'^' # Native data types, manual alignment
+ *                 offset = 0             # <<<<<<<<<<<<<<
+ *                 f = _util_dtypestring(descr, info.format + 1,
+ *                                       info.format + _buffer_format_string_len,
+ */
+    __pyx_v_offset = 0;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":285
+ *                 info.format[0] = c'^' # Native data types, manual alignment
+ *                 offset = 0
+ *                 f = _util_dtypestring(descr, info.format + 1,             # <<<<<<<<<<<<<<
+ *                                       info.format + _buffer_format_string_len,
+ *                                       &offset)
+ */
+    __pyx_t_7 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_7 == NULL)) __PYX_ERR(1, 285, __pyx_L1_error)
+    __pyx_v_f = __pyx_t_7;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":288
+ *                                       info.format + _buffer_format_string_len,
+ *                                       &offset)
+ *                 f[0] = c'\0' # Terminate format string             # <<<<<<<<<<<<<<
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):
+ */
+    (__pyx_v_f[0]) = '\x00';
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":197
+ *         # experimental exception made for __getbuffer__ and __releasebuffer__
+ *         # -- the details of this may change.
+ *         def __getbuffer__(ndarray self, Py_buffer* info, int flags):             # <<<<<<<<<<<<<<
+ *             # This implementation of getbuffer is geared towards Cython
+ *             # requirements, and does not yet fullfill the PEP.
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  if (__pyx_v_info != NULL && __pyx_v_info->obj != NULL) {
+    __Pyx_GOTREF(__pyx_v_info->obj);
+    __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = NULL;
+  }
+  goto __pyx_L2;
+  __pyx_L0:;
+  if (__pyx_v_info != NULL && __pyx_v_info->obj == Py_None) {
+    __Pyx_GOTREF(Py_None);
+    __Pyx_DECREF(Py_None); __pyx_v_info->obj = NULL;
+  }
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_descr);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":290
+ *                 f[0] = c'\0' # Terminate format string
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):             # <<<<<<<<<<<<<<
+ *             if PyArray_HASFIELDS(self):
+ *                 stdlib.free(info.format)
+ */
+
+/* Python wrapper */
+static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/
+static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0);
+  __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) {
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("__releasebuffer__", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":291
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):
+ *             if PyArray_HASFIELDS(self):             # <<<<<<<<<<<<<<
+ *                 stdlib.free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ */
+  __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":292
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):
+ *             if PyArray_HASFIELDS(self):
+ *                 stdlib.free(info.format)             # <<<<<<<<<<<<<<
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ *                 stdlib.free(info.strides)
+ */
+    free(__pyx_v_info->format);
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":291
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):
+ *             if PyArray_HASFIELDS(self):             # <<<<<<<<<<<<<<
+ *                 stdlib.free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ */
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":293
+ *             if PyArray_HASFIELDS(self):
+ *                 stdlib.free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
+ *                 stdlib.free(info.strides)
+ *                 # info.shape was stored after info.strides in the same block
+ */
+  __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":294
+ *                 stdlib.free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ *                 stdlib.free(info.strides)             # <<<<<<<<<<<<<<
+ *                 # info.shape was stored after info.strides in the same block
+ * 
+ */
+    free(__pyx_v_info->strides);
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":293
+ *             if PyArray_HASFIELDS(self):
+ *                 stdlib.free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
+ *                 stdlib.free(info.strides)
+ *                 # info.shape was stored after info.strides in the same block
+ */
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":290
+ *                 f[0] = c'\0' # Terminate format string
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):             # <<<<<<<<<<<<<<
+ *             if PyArray_HASFIELDS(self):
+ *                 stdlib.free(info.format)
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":770
+ * ctypedef npy_cdouble     complex_t
+ * 
+ * cdef inline object PyArray_MultiIterNew1(a):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(1, <void*>a)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":771
+ * 
+ * cdef inline object PyArray_MultiIterNew1(a):
+ *     return PyArray_MultiIterNew(1, <void*>a)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew2(a, b):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 771, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":770
+ * ctypedef npy_cdouble     complex_t
+ * 
+ * cdef inline object PyArray_MultiIterNew1(a):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(1, <void*>a)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":773
+ *     return PyArray_MultiIterNew(1, <void*>a)
+ * 
+ * cdef inline object PyArray_MultiIterNew2(a, b):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(2, <void*>a, <void*>b)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":774
+ * 
+ * cdef inline object PyArray_MultiIterNew2(a, b):
+ *     return PyArray_MultiIterNew(2, <void*>a, <void*>b)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew3(a, b, c):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 774, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":773
+ *     return PyArray_MultiIterNew(1, <void*>a)
+ * 
+ * cdef inline object PyArray_MultiIterNew2(a, b):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(2, <void*>a, <void*>b)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":776
+ *     return PyArray_MultiIterNew(2, <void*>a, <void*>b)
+ * 
+ * cdef inline object PyArray_MultiIterNew3(a, b, c):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":777
+ * 
+ * cdef inline object PyArray_MultiIterNew3(a, b, c):
+ *     return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew4(a, b, c, d):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 777, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":776
+ *     return PyArray_MultiIterNew(2, <void*>a, <void*>b)
+ * 
+ * cdef inline object PyArray_MultiIterNew3(a, b, c):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":779
+ *     return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
+ * 
+ * cdef inline object PyArray_MultiIterNew4(a, b, c, d):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":780
+ * 
+ * cdef inline object PyArray_MultiIterNew4(a, b, c, d):
+ *     return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 780, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":779
+ *     return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
+ * 
+ * cdef inline object PyArray_MultiIterNew4(a, b, c, d):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":782
+ *     return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
+ * 
+ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":783
+ * 
+ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
+ *     return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 783, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":782
+ *     return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
+ * 
+ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":785
+ *     return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
+ * 
+ * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:             # <<<<<<<<<<<<<<
+ *     # Recursive utility function used in __getbuffer__ to get format
+ *     # string. The new location in the format string is returned.
+ */
+
+static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) {
+  PyArray_Descr *__pyx_v_child = 0;
+  int __pyx_v_endian_detector;
+  int __pyx_v_little_endian;
+  PyObject *__pyx_v_fields = 0;
+  PyObject *__pyx_v_childname = NULL;
+  PyObject *__pyx_v_new_offset = NULL;
+  PyObject *__pyx_v_t = NULL;
+  char *__pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  Py_ssize_t __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  int __pyx_t_6;
+  int __pyx_t_7;
+  long __pyx_t_8;
+  char *__pyx_t_9;
+  __Pyx_RefNannySetupContext("_util_dtypestring", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":790
+ * 
+ *     cdef dtype child
+ *     cdef int endian_detector = 1             # <<<<<<<<<<<<<<
+ *     cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)
+ *     cdef tuple fields
+ */
+  __pyx_v_endian_detector = 1;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":791
+ *     cdef dtype child
+ *     cdef int endian_detector = 1
+ *     cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)             # <<<<<<<<<<<<<<
+ *     cdef tuple fields
+ * 
+ */
+  __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":794
+ *     cdef tuple fields
+ * 
+ *     for childname in descr.names:             # <<<<<<<<<<<<<<
+ *         fields = descr.fields[childname]
+ *         child, new_offset = fields
+ */
+  if (unlikely(__pyx_v_descr->names == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+    __PYX_ERR(1, 794, __pyx_L1_error)
+  }
+  __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
+  for (;;) {
+    if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 794, __pyx_L1_error)
+    #else
+    __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 794, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    #endif
+    __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":795
+ * 
+ *     for childname in descr.names:
+ *         fields = descr.fields[childname]             # <<<<<<<<<<<<<<
+ *         child, new_offset = fields
+ * 
+ */
+    if (unlikely(__pyx_v_descr->fields == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(1, 795, __pyx_L1_error)
+    }
+    __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 795, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 795, __pyx_L1_error)
+    __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3));
+    __pyx_t_3 = 0;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":796
+ *     for childname in descr.names:
+ *         fields = descr.fields[childname]
+ *         child, new_offset = fields             # <<<<<<<<<<<<<<
+ * 
+ *         if (end - f) - <int>(new_offset - offset[0]) < 15:
+ */
+    if (likely(__pyx_v_fields != Py_None)) {
+      PyObject* sequence = __pyx_v_fields;
+      #if !CYTHON_COMPILING_IN_PYPY
+      Py_ssize_t size = Py_SIZE(sequence);
+      #else
+      Py_ssize_t size = PySequence_Size(sequence);
+      #endif
+      if (unlikely(size != 2)) {
+        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+        __PYX_ERR(1, 796, __pyx_L1_error)
+      }
+      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); 
+      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); 
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_4);
+      #else
+      __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 796, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 796, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      #endif
+    } else {
+      __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 796, __pyx_L1_error)
+    }
+    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 796, __pyx_L1_error)
+    __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3));
+    __pyx_t_3 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":798
+ *         child, new_offset = fields
+ * 
+ *         if (end - f) - <int>(new_offset - offset[0]) < 15:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 798, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 798, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 798, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0);
+    if (__pyx_t_6) {
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":799
+ * 
+ *         if (end - f) - <int>(new_offset - offset[0]) < 15:
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")             # <<<<<<<<<<<<<<
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 799, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(1, 799, __pyx_L1_error)
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":798
+ *         child, new_offset = fields
+ * 
+ *         if (end - f) - <int>(new_offset - offset[0]) < 15:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ */
+    }
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")
+ */
+    __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0);
+    if (!__pyx_t_7) {
+      goto __pyx_L8_next_or;
+    } else {
+    }
+    __pyx_t_7 = (__pyx_v_little_endian != 0);
+    if (!__pyx_t_7) {
+    } else {
+      __pyx_t_6 = __pyx_t_7;
+      goto __pyx_L7_bool_binop_done;
+    }
+    __pyx_L8_next_or:;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":802
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or
+ *             (child.byteorder == c'<' and not little_endian)):             # <<<<<<<<<<<<<<
+ *             raise ValueError(u"Non-native byte order not supported")
+ *             # One could encode it in the format string and have Cython
+ */
+    __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0);
+    if (__pyx_t_7) {
+    } else {
+      __pyx_t_6 = __pyx_t_7;
+      goto __pyx_L7_bool_binop_done;
+    }
+    __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0);
+    __pyx_t_6 = __pyx_t_7;
+    __pyx_L7_bool_binop_done:;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")
+ */
+    if (__pyx_t_6) {
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":803
+ *         if ((child.byteorder == c'>' and little_endian) or
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
+ *             # One could encode it in the format string and have Cython
+ *             # complain instead, BUT: < and > in format strings also imply
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__27, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 803, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(1, 803, __pyx_L1_error)
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")
+ */
+    }
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":813
+ * 
+ *         # Output padding bytes
+ *         while offset[0] < new_offset:             # <<<<<<<<<<<<<<
+ *             f[0] = 120 # "x"; pad byte
+ *             f += 1
+ */
+    while (1) {
+      __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 813, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 813, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 813, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (!__pyx_t_6) break;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":814
+ *         # Output padding bytes
+ *         while offset[0] < new_offset:
+ *             f[0] = 120 # "x"; pad byte             # <<<<<<<<<<<<<<
+ *             f += 1
+ *             offset[0] += 1
+ */
+      (__pyx_v_f[0]) = 0x78;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":815
+ *         while offset[0] < new_offset:
+ *             f[0] = 120 # "x"; pad byte
+ *             f += 1             # <<<<<<<<<<<<<<
+ *             offset[0] += 1
+ * 
+ */
+      __pyx_v_f = (__pyx_v_f + 1);
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":816
+ *             f[0] = 120 # "x"; pad byte
+ *             f += 1
+ *             offset[0] += 1             # <<<<<<<<<<<<<<
+ * 
+ *         offset[0] += child.itemsize
+ */
+      __pyx_t_8 = 0;
+      (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1);
+    }
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":818
+ *             offset[0] += 1
+ * 
+ *         offset[0] += child.itemsize             # <<<<<<<<<<<<<<
+ * 
+ *         if not PyDataType_HASFIELDS(child):
+ */
+    __pyx_t_8 = 0;
+    (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize);
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":820
+ *         offset[0] += child.itemsize
+ * 
+ *         if not PyDataType_HASFIELDS(child):             # <<<<<<<<<<<<<<
+ *             t = child.type_num
+ *             if end - f < 5:
+ */
+    __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0);
+    if (__pyx_t_6) {
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":821
+ * 
+ *         if not PyDataType_HASFIELDS(child):
+ *             t = child.type_num             # <<<<<<<<<<<<<<
+ *             if end - f < 5:
+ *                 raise RuntimeError(u"Format string allocated too short.")
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 821, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4);
+      __pyx_t_4 = 0;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":822
+ *         if not PyDataType_HASFIELDS(child):
+ *             t = child.type_num
+ *             if end - f < 5:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(u"Format string allocated too short.")
+ * 
+ */
+      __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0);
+      if (__pyx_t_6) {
+
+        /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":823
+ *             t = child.type_num
+ *             if end - f < 5:
+ *                 raise RuntimeError(u"Format string allocated too short.")             # <<<<<<<<<<<<<<
+ * 
+ *             # Until ticket #99 is fixed, use integers to avoid warnings
+ */
+        __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__28, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 823, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __PYX_ERR(1, 823, __pyx_L1_error)
+
+        /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":822
+ *         if not PyDataType_HASFIELDS(child):
+ *             t = child.type_num
+ *             if end - f < 5:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(u"Format string allocated too short.")
+ * 
+ */
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":826
+ * 
+ *             # Until ticket #99 is fixed, use integers to avoid warnings
+ *             if   t == NPY_BYTE:        f[0] =  98 #"b"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 826, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 826, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 826, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 98;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":827
+ *             # Until ticket #99 is fixed, use integers to avoid warnings
+ *             if   t == NPY_BYTE:        f[0] =  98 #"b"
+ *             elif t == NPY_UBYTE:       f[0] =  66 #"B"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 827, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 827, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 827, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 66;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":828
+ *             if   t == NPY_BYTE:        f[0] =  98 #"b"
+ *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"
+ *             elif t == NPY_INT:         f[0] = 105 #"i"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 828, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 828, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 828, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x68;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":829
+ *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_INT:         f[0] = 105 #"i"
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 829, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 829, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 829, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 72;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":830
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"
+ *             elif t == NPY_INT:         f[0] = 105 #"i"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 830, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 830, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 830, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x69;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":831
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"
+ *             elif t == NPY_INT:         f[0] = 105 #"i"
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 831, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 831, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 831, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 73;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":832
+ *             elif t == NPY_INT:         f[0] = 105 #"i"
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 832, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 832, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 832, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x6C;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":833
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 833, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 833, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 833, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 76;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":834
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 834, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 834, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 834, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x71;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":835
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 835, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 835, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 835, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 81;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":836
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 836, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 836, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 836, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x66;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":837
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 837, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 837, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 837, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x64;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":838
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 838, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 838, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 838, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x67;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":839
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf             # <<<<<<<<<<<<<<
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
+ *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 839, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 839, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 839, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 90;
+        (__pyx_v_f[1]) = 0x66;
+        __pyx_v_f = (__pyx_v_f + 1);
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":840
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd             # <<<<<<<<<<<<<<
+ *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
+ *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 840, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 840, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 840, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 90;
+        (__pyx_v_f[1]) = 0x64;
+        __pyx_v_f = (__pyx_v_f + 1);
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":841
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
+ *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg             # <<<<<<<<<<<<<<
+ *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
+ *             else:
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 841, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 841, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 841, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 90;
+        (__pyx_v_f[1]) = 0x67;
+        __pyx_v_f = (__pyx_v_f + 1);
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":842
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
+ *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
+ *             elif t == NPY_OBJECT:      f[0] = 79 #"O"             # <<<<<<<<<<<<<<
+ *             else:
+ *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 842, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 842, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 842, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 79;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":844
+ *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
+ *             else:
+ *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)             # <<<<<<<<<<<<<<
+ *             f += 1
+ *         else:
+ */
+      /*else*/ {
+        __pyx_t_3 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 844, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 844, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GIVEREF(__pyx_t_3);
+        PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
+        __pyx_t_3 = 0;
+        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 844, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __PYX_ERR(1, 844, __pyx_L1_error)
+      }
+      __pyx_L15:;
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":845
+ *             else:
+ *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ *             f += 1             # <<<<<<<<<<<<<<
+ *         else:
+ *             # Cython ignores struct boundary information ("T{...}"),
+ */
+      __pyx_v_f = (__pyx_v_f + 1);
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":820
+ *         offset[0] += child.itemsize
+ * 
+ *         if not PyDataType_HASFIELDS(child):             # <<<<<<<<<<<<<<
+ *             t = child.type_num
+ *             if end - f < 5:
+ */
+      goto __pyx_L13;
+    }
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":849
+ *             # Cython ignores struct boundary information ("T{...}"),
+ *             # so don't output it
+ *             f = _util_dtypestring(child, f, end, offset)             # <<<<<<<<<<<<<<
+ *     return f
+ * 
+ */
+    /*else*/ {
+      __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == NULL)) __PYX_ERR(1, 849, __pyx_L1_error)
+      __pyx_v_f = __pyx_t_9;
+    }
+    __pyx_L13:;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":794
+ *     cdef tuple fields
+ * 
+ *     for childname in descr.names:             # <<<<<<<<<<<<<<
+ *         fields = descr.fields[childname]
+ *         child, new_offset = fields
+ */
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":850
+ *             # so don't output it
+ *             f = _util_dtypestring(child, f, end, offset)
+ *     return f             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = __pyx_v_f;
+  goto __pyx_L0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":785
+ *     return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
+ * 
+ * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:             # <<<<<<<<<<<<<<
+ *     # Recursive utility function used in __getbuffer__ to get format
+ *     # string. The new location in the format string is returned.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_child);
+  __Pyx_XDECREF(__pyx_v_fields);
+  __Pyx_XDECREF(__pyx_v_childname);
+  __Pyx_XDECREF(__pyx_v_new_offset);
+  __Pyx_XDECREF(__pyx_v_t);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":966
+ * 
+ * 
+ * cdef inline void set_array_base(ndarray arr, object base):             # <<<<<<<<<<<<<<
+ *      cdef PyObject* baseptr
+ *      if base is None:
+ */
+
+static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) {
+  PyObject *__pyx_v_baseptr;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  __Pyx_RefNannySetupContext("set_array_base", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":968
+ * cdef inline void set_array_base(ndarray arr, object base):
+ *      cdef PyObject* baseptr
+ *      if base is None:             # <<<<<<<<<<<<<<
+ *          baseptr = NULL
+ *      else:
+ */
+  __pyx_t_1 = (__pyx_v_base == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":969
+ *      cdef PyObject* baseptr
+ *      if base is None:
+ *          baseptr = NULL             # <<<<<<<<<<<<<<
+ *      else:
+ *          Py_INCREF(base) # important to do this before decref below!
+ */
+    __pyx_v_baseptr = NULL;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":968
+ * cdef inline void set_array_base(ndarray arr, object base):
+ *      cdef PyObject* baseptr
+ *      if base is None:             # <<<<<<<<<<<<<<
+ *          baseptr = NULL
+ *      else:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":971
+ *          baseptr = NULL
+ *      else:
+ *          Py_INCREF(base) # important to do this before decref below!             # <<<<<<<<<<<<<<
+ *          baseptr = <PyObject*>base
+ *      Py_XDECREF(arr.base)
+ */
+  /*else*/ {
+    Py_INCREF(__pyx_v_base);
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":972
+ *      else:
+ *          Py_INCREF(base) # important to do this before decref below!
+ *          baseptr = <PyObject*>base             # <<<<<<<<<<<<<<
+ *      Py_XDECREF(arr.base)
+ *      arr.base = baseptr
+ */
+    __pyx_v_baseptr = ((PyObject *)__pyx_v_base);
+  }
+  __pyx_L3:;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":973
+ *          Py_INCREF(base) # important to do this before decref below!
+ *          baseptr = <PyObject*>base
+ *      Py_XDECREF(arr.base)             # <<<<<<<<<<<<<<
+ *      arr.base = baseptr
+ * 
+ */
+  Py_XDECREF(__pyx_v_arr->base);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":974
+ *          baseptr = <PyObject*>base
+ *      Py_XDECREF(arr.base)
+ *      arr.base = baseptr             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object get_array_base(ndarray arr):
+ */
+  __pyx_v_arr->base = __pyx_v_baseptr;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":966
+ * 
+ * 
+ * cdef inline void set_array_base(ndarray arr, object base):             # <<<<<<<<<<<<<<
+ *      cdef PyObject* baseptr
+ *      if base is None:
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976
+ *      arr.base = baseptr
+ * 
+ * cdef inline object get_array_base(ndarray arr):             # <<<<<<<<<<<<<<
+ *     if arr.base is NULL:
+ *         return None
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("get_array_base", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":977
+ * 
+ * cdef inline object get_array_base(ndarray arr):
+ *     if arr.base is NULL:             # <<<<<<<<<<<<<<
+ *         return None
+ *     else:
+ */
+  __pyx_t_1 = ((__pyx_v_arr->base == NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":978
+ * cdef inline object get_array_base(ndarray arr):
+ *     if arr.base is NULL:
+ *         return None             # <<<<<<<<<<<<<<
+ *     else:
+ *         return <object>arr.base
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(Py_None);
+    __pyx_r = Py_None;
+    goto __pyx_L0;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":977
+ * 
+ * cdef inline object get_array_base(ndarray arr):
+ *     if arr.base is NULL:             # <<<<<<<<<<<<<<
+ *         return None
+ *     else:
+ */
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":980
+ *         return None
+ *     else:
+ *         return <object>arr.base             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  /*else*/ {
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(((PyObject *)__pyx_v_arr->base));
+    __pyx_r = ((PyObject *)__pyx_v_arr->base);
+    goto __pyx_L0;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976
+ *      arr.base = baseptr
+ * 
+ * cdef inline object get_array_base(ndarray arr):             # <<<<<<<<<<<<<<
+ *     if arr.base is NULL:
+ *         return None
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":985
+ * # Versions of the import_* functions which are more suitable for
+ * # Cython code.
+ * cdef inline int import_array() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_array()
+ */
+
+static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  __Pyx_RefNannySetupContext("import_array", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":986
+ * # Cython code.
+ * cdef inline int import_array() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_array()
+ *     except Exception:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":987
+ * cdef inline int import_array() except -1:
+ *     try:
+ *         _import_array()             # <<<<<<<<<<<<<<
+ *     except Exception:
+ *         raise ImportError("numpy.core.multiarray failed to import")
+ */
+      __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(1, 987, __pyx_L3_error)
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":986
+ * # Cython code.
+ * cdef inline int import_array() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_array()
+ *     except Exception:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L10_try_end;
+    __pyx_L3_error:;
+    __Pyx_PyThreadState_assign
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":988
+ *     try:
+ *         _import_array()
+ *     except Exception:             # <<<<<<<<<<<<<<
+ *         raise ImportError("numpy.core.multiarray failed to import")
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_4) {
+      __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 988, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":989
+ *         _import_array()
+ *     except Exception:
+ *         raise ImportError("numpy.core.multiarray failed to import")             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline int import_umath() except -1:
+ */
+      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__29, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 989, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_Raise(__pyx_t_8, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __PYX_ERR(1, 989, __pyx_L5_except_error)
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":986
+ * # Cython code.
+ * cdef inline int import_array() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_array()
+ *     except Exception:
+ */
+    __Pyx_PyThreadState_assign
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L10_try_end:;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":985
+ * # Versions of the import_* functions which are more suitable for
+ * # Cython code.
+ * cdef inline int import_array() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_array()
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":991
+ *         raise ImportError("numpy.core.multiarray failed to import")
+ * 
+ * cdef inline int import_umath() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_umath()
+ */
+
+static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  __Pyx_RefNannySetupContext("import_umath", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":992
+ * 
+ * cdef inline int import_umath() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":993
+ * cdef inline int import_umath() except -1:
+ *     try:
+ *         _import_umath()             # <<<<<<<<<<<<<<
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")
+ */
+      __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(1, 993, __pyx_L3_error)
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":992
+ * 
+ * cdef inline int import_umath() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L10_try_end;
+    __pyx_L3_error:;
+    __Pyx_PyThreadState_assign
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":994
+ *     try:
+ *         _import_umath()
+ *     except Exception:             # <<<<<<<<<<<<<<
+ *         raise ImportError("numpy.core.umath failed to import")
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_4) {
+      __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 994, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":995
+ *         _import_umath()
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline int import_ufunc() except -1:
+ */
+      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__30, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 995, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_Raise(__pyx_t_8, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __PYX_ERR(1, 995, __pyx_L5_except_error)
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":992
+ * 
+ * cdef inline int import_umath() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+    __Pyx_PyThreadState_assign
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L10_try_end:;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":991
+ *         raise ImportError("numpy.core.multiarray failed to import")
+ * 
+ * cdef inline int import_umath() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_umath()
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":997
+ *         raise ImportError("numpy.core.umath failed to import")
+ * 
+ * cdef inline int import_ufunc() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_umath()
+ */
+
+static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  __Pyx_RefNannySetupContext("import_ufunc", 0);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":998
+ * 
+ * cdef inline int import_ufunc() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":999
+ * cdef inline int import_ufunc() except -1:
+ *     try:
+ *         _import_umath()             # <<<<<<<<<<<<<<
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")
+ */
+      __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(1, 999, __pyx_L3_error)
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":998
+ * 
+ * cdef inline int import_ufunc() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L10_try_end;
+    __pyx_L3_error:;
+    __Pyx_PyThreadState_assign
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":1000
+ *     try:
+ *         _import_umath()
+ *     except Exception:             # <<<<<<<<<<<<<<
+ *         raise ImportError("numpy.core.umath failed to import")
+ */
+    __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_4) {
+      __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1000, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":1001
+ *         _import_umath()
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")             # <<<<<<<<<<<<<<
+ */
+      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__31, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1001, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_Raise(__pyx_t_8, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __PYX_ERR(1, 1001, __pyx_L5_except_error)
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":998
+ * 
+ * cdef inline int import_ufunc() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+    __Pyx_PyThreadState_assign
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L10_try_end:;
+  }
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":997
+ *         raise ImportError("numpy.core.umath failed to import")
+ * 
+ * cdef inline int import_ufunc() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_umath()
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyMethodDef __pyx_methods[] = {
+  {0, 0, 0, 0}
+};
+
+#if PY_MAJOR_VERSION >= 3
+static struct PyModuleDef __pyx_moduledef = {
+  #if PY_VERSION_HEX < 0x03020000
+    { PyObject_HEAD_INIT(NULL) NULL, 0, NULL },
+  #else
+    PyModuleDef_HEAD_INIT,
+  #endif
+    "cython_nms",
+    0, /* m_doc */
+    -1, /* m_size */
+    __pyx_methods /* m_methods */,
+    NULL, /* m_reload */
+    NULL, /* m_traverse */
+    NULL, /* m_clear */
+    NULL /* m_free */
+};
+#endif
+
+static __Pyx_StringTabEntry __pyx_string_tab[] = {
+  {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0},
+  {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0},
+  {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1},
+  {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0},
+  {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1},
+  {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1},
+  {&__pyx_n_s_areas, __pyx_k_areas, sizeof(__pyx_k_areas), 0, 0, 1, 1},
+  {&__pyx_n_s_argsort, __pyx_k_argsort, sizeof(__pyx_k_argsort), 0, 0, 1, 1},
+  {&__pyx_n_s_cython_nms, __pyx_k_cython_nms, sizeof(__pyx_k_cython_nms), 0, 0, 1, 1},
+  {&__pyx_n_s_dets, __pyx_k_dets, sizeof(__pyx_k_dets), 0, 0, 1, 1},
+  {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1},
+  {&__pyx_n_s_h, __pyx_k_h, sizeof(__pyx_k_h), 0, 0, 1, 1},
+  {&__pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_k_home_yjr_PycharmProjects_Faster, sizeof(__pyx_k_home_yjr_PycharmProjects_Faster), 0, 0, 1, 0},
+  {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1},
+  {&__pyx_n_s_i_2, __pyx_k_i_2, sizeof(__pyx_k_i_2), 0, 0, 1, 1},
+  {&__pyx_n_s_iarea, __pyx_k_iarea, sizeof(__pyx_k_iarea), 0, 0, 1, 1},
+  {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
+  {&__pyx_n_s_int, __pyx_k_int, sizeof(__pyx_k_int), 0, 0, 1, 1},
+  {&__pyx_n_s_inter, __pyx_k_inter, sizeof(__pyx_k_inter), 0, 0, 1, 1},
+  {&__pyx_n_s_ix1, __pyx_k_ix1, sizeof(__pyx_k_ix1), 0, 0, 1, 1},
+  {&__pyx_n_s_ix2, __pyx_k_ix2, sizeof(__pyx_k_ix2), 0, 0, 1, 1},
+  {&__pyx_n_s_iy1, __pyx_k_iy1, sizeof(__pyx_k_iy1), 0, 0, 1, 1},
+  {&__pyx_n_s_iy2, __pyx_k_iy2, sizeof(__pyx_k_iy2), 0, 0, 1, 1},
+  {&__pyx_n_s_j, __pyx_k_j, sizeof(__pyx_k_j), 0, 0, 1, 1},
+  {&__pyx_n_s_j_2, __pyx_k_j_2, sizeof(__pyx_k_j_2), 0, 0, 1, 1},
+  {&__pyx_n_s_keep, __pyx_k_keep, sizeof(__pyx_k_keep), 0, 0, 1, 1},
+  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
+  {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0},
+  {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0},
+  {&__pyx_n_s_ndets, __pyx_k_ndets, sizeof(__pyx_k_ndets), 0, 0, 1, 1},
+  {&__pyx_n_s_nms, __pyx_k_nms, sizeof(__pyx_k_nms), 0, 0, 1, 1},
+  {&__pyx_n_s_nms_new, __pyx_k_nms_new, sizeof(__pyx_k_nms_new), 0, 0, 1, 1},
+  {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1},
+  {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1},
+  {&__pyx_kp_s_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 0, 1, 0},
+  {&__pyx_kp_s_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 0, 1, 0},
+  {&__pyx_n_s_order, __pyx_k_order, sizeof(__pyx_k_order), 0, 0, 1, 1},
+  {&__pyx_n_s_ovr, __pyx_k_ovr, sizeof(__pyx_k_ovr), 0, 0, 1, 1},
+  {&__pyx_n_s_ovr1, __pyx_k_ovr1, sizeof(__pyx_k_ovr1), 0, 0, 1, 1},
+  {&__pyx_n_s_ovr2, __pyx_k_ovr2, sizeof(__pyx_k_ovr2), 0, 0, 1, 1},
+  {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1},
+  {&__pyx_n_s_scores, __pyx_k_scores, sizeof(__pyx_k_scores), 0, 0, 1, 1},
+  {&__pyx_n_s_suppressed, __pyx_k_suppressed, sizeof(__pyx_k_suppressed), 0, 0, 1, 1},
+  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
+  {&__pyx_n_s_thresh, __pyx_k_thresh, sizeof(__pyx_k_thresh), 0, 0, 1, 1},
+  {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0},
+  {&__pyx_n_s_w, __pyx_k_w, sizeof(__pyx_k_w), 0, 0, 1, 1},
+  {&__pyx_n_s_x1, __pyx_k_x1, sizeof(__pyx_k_x1), 0, 0, 1, 1},
+  {&__pyx_n_s_x2, __pyx_k_x2, sizeof(__pyx_k_x2), 0, 0, 1, 1},
+  {&__pyx_n_s_xx1, __pyx_k_xx1, sizeof(__pyx_k_xx1), 0, 0, 1, 1},
+  {&__pyx_n_s_xx2, __pyx_k_xx2, sizeof(__pyx_k_xx2), 0, 0, 1, 1},
+  {&__pyx_n_s_y1, __pyx_k_y1, sizeof(__pyx_k_y1), 0, 0, 1, 1},
+  {&__pyx_n_s_y2, __pyx_k_y2, sizeof(__pyx_k_y2), 0, 0, 1, 1},
+  {&__pyx_n_s_yy1, __pyx_k_yy1, sizeof(__pyx_k_yy1), 0, 0, 1, 1},
+  {&__pyx_n_s_yy2, __pyx_k_yy2, sizeof(__pyx_k_yy2), 0, 0, 1, 1},
+  {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1},
+  {0, 0, 0, 0, 0, 0, 0}
+};
+static int __Pyx_InitCachedBuiltins(void) {
+  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 43, __pyx_L1_error)
+  __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 218, __pyx_L1_error)
+  __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 799, __pyx_L1_error)
+  __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 989, __pyx_L1_error)
+  return 0;
+  __pyx_L1_error:;
+  return -1;
+}
+
+static int __Pyx_InitCachedConstants(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
+
+  /* "nms.pyx":18
+ * 
+ * def nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):
+ *     cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ *     cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]
+ */
+  __pyx_slice_ = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice_)) __PYX_ERR(0, 18, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_slice_);
+  __Pyx_GIVEREF(__pyx_slice_);
+  __pyx_tuple__2 = PyTuple_Pack(2, __pyx_slice_, __pyx_int_0); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 18, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__2);
+  __Pyx_GIVEREF(__pyx_tuple__2);
+
+  /* "nms.pyx":19
+ * def nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):
+ *     cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3]
+ */
+  __pyx_slice__3 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__3)) __PYX_ERR(0, 19, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_slice__3);
+  __Pyx_GIVEREF(__pyx_slice__3);
+  __pyx_tuple__4 = PyTuple_Pack(2, __pyx_slice__3, __pyx_int_1); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 19, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__4);
+  __Pyx_GIVEREF(__pyx_tuple__4);
+
+  /* "nms.pyx":20
+ *     cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ *     cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3]
+ *     cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4]
+ */
+  __pyx_slice__5 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__5)) __PYX_ERR(0, 20, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_slice__5);
+  __Pyx_GIVEREF(__pyx_slice__5);
+  __pyx_tuple__6 = PyTuple_Pack(2, __pyx_slice__5, __pyx_int_2); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 20, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__6);
+  __Pyx_GIVEREF(__pyx_tuple__6);
+
+  /* "nms.pyx":21
+ *     cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ *     cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3]             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4]
+ * 
+ */
+  __pyx_slice__7 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__7)) __PYX_ERR(0, 21, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_slice__7);
+  __Pyx_GIVEREF(__pyx_slice__7);
+  __pyx_tuple__8 = PyTuple_Pack(2, __pyx_slice__7, __pyx_int_3); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 21, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__8);
+  __Pyx_GIVEREF(__pyx_tuple__8);
+
+  /* "nms.pyx":22
+ *     cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3]
+ *     cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4]             # <<<<<<<<<<<<<<
+ * 
+ *     cdef np.ndarray[np.float32_t, ndim=1] areas = (x2 - x1 + 1) * (y2 - y1 + 1)
+ */
+  __pyx_slice__9 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__9)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_slice__9);
+  __Pyx_GIVEREF(__pyx_slice__9);
+  __pyx_tuple__10 = PyTuple_Pack(2, __pyx_slice__9, __pyx_int_4); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__10);
+  __Pyx_GIVEREF(__pyx_tuple__10);
+
+  /* "nms.pyx":25
+ * 
+ *     cdef np.ndarray[np.float32_t, ndim=1] areas = (x2 - x1 + 1) * (y2 - y1 + 1)
+ *     cdef np.ndarray[np.int_t, ndim=1] order = scores.argsort()[::-1]             # <<<<<<<<<<<<<<
+ * 
+ *     cdef int ndets = dets.shape[0]
+ */
+  __pyx_slice__11 = PySlice_New(Py_None, Py_None, __pyx_int_neg_1); if (unlikely(!__pyx_slice__11)) __PYX_ERR(0, 25, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_slice__11);
+  __Pyx_GIVEREF(__pyx_slice__11);
+
+  /* "nms.pyx":71
+ * 
+ * def nms_new(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):
+ *     cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ *     cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]
+ */
+  __pyx_slice__12 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__12)) __PYX_ERR(0, 71, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_slice__12);
+  __Pyx_GIVEREF(__pyx_slice__12);
+  __pyx_tuple__13 = PyTuple_Pack(2, __pyx_slice__12, __pyx_int_0); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 71, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__13);
+  __Pyx_GIVEREF(__pyx_tuple__13);
+
+  /* "nms.pyx":72
+ * def nms_new(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):
+ *     cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3]
+ */
+  __pyx_slice__14 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__14)) __PYX_ERR(0, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_slice__14);
+  __Pyx_GIVEREF(__pyx_slice__14);
+  __pyx_tuple__15 = PyTuple_Pack(2, __pyx_slice__14, __pyx_int_1); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__15);
+  __Pyx_GIVEREF(__pyx_tuple__15);
+
+  /* "nms.pyx":73
+ *     cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ *     cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3]
+ *     cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4]
+ */
+  __pyx_slice__16 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__16)) __PYX_ERR(0, 73, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_slice__16);
+  __Pyx_GIVEREF(__pyx_slice__16);
+  __pyx_tuple__17 = PyTuple_Pack(2, __pyx_slice__16, __pyx_int_2); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 73, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__17);
+  __Pyx_GIVEREF(__pyx_tuple__17);
+
+  /* "nms.pyx":74
+ *     cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ *     cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3]             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4]
+ * 
+ */
+  __pyx_slice__18 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__18)) __PYX_ERR(0, 74, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_slice__18);
+  __Pyx_GIVEREF(__pyx_slice__18);
+  __pyx_tuple__19 = PyTuple_Pack(2, __pyx_slice__18, __pyx_int_3); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 74, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__19);
+  __Pyx_GIVEREF(__pyx_tuple__19);
+
+  /* "nms.pyx":75
+ *     cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3]
+ *     cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4]             # <<<<<<<<<<<<<<
+ * 
+ *     cdef np.ndarray[np.float32_t, ndim=1] areas = (x2 - x1 + 1) * (y2 - y1 + 1)
+ */
+  __pyx_slice__20 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__20)) __PYX_ERR(0, 75, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_slice__20);
+  __Pyx_GIVEREF(__pyx_slice__20);
+  __pyx_tuple__21 = PyTuple_Pack(2, __pyx_slice__20, __pyx_int_4); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 75, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__21);
+  __Pyx_GIVEREF(__pyx_tuple__21);
+
+  /* "nms.pyx":78
+ * 
+ *     cdef np.ndarray[np.float32_t, ndim=1] areas = (x2 - x1 + 1) * (y2 - y1 + 1)
+ *     cdef np.ndarray[np.int_t, ndim=1] order = scores.argsort()[::-1]             # <<<<<<<<<<<<<<
+ * 
+ *     cdef int ndets = dets.shape[0]
+ */
+  __pyx_slice__22 = PySlice_New(Py_None, Py_None, __pyx_int_neg_1); if (unlikely(!__pyx_slice__22)) __PYX_ERR(0, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_slice__22);
+  __Pyx_GIVEREF(__pyx_slice__22);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":218
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")             # <<<<<<<<<<<<<<
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ */
+  __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(1, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__23);
+  __Pyx_GIVEREF(__pyx_tuple__23);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":222
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")             # <<<<<<<<<<<<<<
+ * 
+ *             info.buf = PyArray_DATA(self)
+ */
+  __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(1, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__24);
+  __Pyx_GIVEREF(__pyx_tuple__24);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":259
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
+ *                 if   t == NPY_BYTE:        f = "b"
+ *                 elif t == NPY_UBYTE:       f = "B"
+ */
+  __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(1, 259, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__25);
+  __Pyx_GIVEREF(__pyx_tuple__25);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":799
+ * 
+ *         if (end - f) - <int>(new_offset - offset[0]) < 15:
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")             # <<<<<<<<<<<<<<
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or
+ */
+  __pyx_tuple__26 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(1, 799, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__26);
+  __Pyx_GIVEREF(__pyx_tuple__26);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":803
+ *         if ((child.byteorder == c'>' and little_endian) or
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
+ *             # One could encode it in the format string and have Cython
+ *             # complain instead, BUT: < and > in format strings also imply
+ */
+  __pyx_tuple__27 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(1, 803, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__27);
+  __Pyx_GIVEREF(__pyx_tuple__27);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":823
+ *             t = child.type_num
+ *             if end - f < 5:
+ *                 raise RuntimeError(u"Format string allocated too short.")             # <<<<<<<<<<<<<<
+ * 
+ *             # Until ticket #99 is fixed, use integers to avoid warnings
+ */
+  __pyx_tuple__28 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(1, 823, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__28);
+  __Pyx_GIVEREF(__pyx_tuple__28);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":989
+ *         _import_array()
+ *     except Exception:
+ *         raise ImportError("numpy.core.multiarray failed to import")             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline int import_umath() except -1:
+ */
+  __pyx_tuple__29 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(1, 989, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__29);
+  __Pyx_GIVEREF(__pyx_tuple__29);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":995
+ *         _import_umath()
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline int import_ufunc() except -1:
+ */
+  __pyx_tuple__30 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(1, 995, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__30);
+  __Pyx_GIVEREF(__pyx_tuple__30);
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":1001
+ *         _import_umath()
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")             # <<<<<<<<<<<<<<
+ */
+  __pyx_tuple__31 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(1, 1001, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__31);
+  __Pyx_GIVEREF(__pyx_tuple__31);
+
+  /* "nms.pyx":17
+ *     return a if a <= b else b
+ * 
+ * def nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ */
+  __pyx_tuple__32 = PyTuple_Pack(29, __pyx_n_s_dets, __pyx_n_s_thresh, __pyx_n_s_x1, __pyx_n_s_y1, __pyx_n_s_x2, __pyx_n_s_y2, __pyx_n_s_scores, __pyx_n_s_areas, __pyx_n_s_order, __pyx_n_s_ndets, __pyx_n_s_suppressed, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_i_2, __pyx_n_s_j_2, __pyx_n_s_ix1, __pyx_n_s_iy1, __pyx_n_s_ix2, __pyx_n_s_iy2, __pyx_n_s_iarea, __pyx_n_s_xx1, __pyx_n_s_yy1, __pyx_n_s_xx2, __pyx_n_s_yy2, __pyx_n_s_w, __pyx_n_s_h, __pyx_n_s_inter, __pyx_n_s_ovr, __pyx_n_s_keep); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 17, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__32);
+  __Pyx_GIVEREF(__pyx_tuple__32);
+  __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(2, 0, 29, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__32, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_n_s_nms, 17, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(0, 17, __pyx_L1_error)
+
+  /* "nms.pyx":70
+ *     return keep
+ * 
+ * def nms_new(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ */
+  __pyx_tuple__34 = PyTuple_Pack(31, __pyx_n_s_dets, __pyx_n_s_thresh, __pyx_n_s_x1, __pyx_n_s_y1, __pyx_n_s_x2, __pyx_n_s_y2, __pyx_n_s_scores, __pyx_n_s_areas, __pyx_n_s_order, __pyx_n_s_ndets, __pyx_n_s_suppressed, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_i_2, __pyx_n_s_j_2, __pyx_n_s_ix1, __pyx_n_s_iy1, __pyx_n_s_ix2, __pyx_n_s_iy2, __pyx_n_s_iarea, __pyx_n_s_xx1, __pyx_n_s_yy1, __pyx_n_s_xx2, __pyx_n_s_yy2, __pyx_n_s_w, __pyx_n_s_h, __pyx_n_s_inter, __pyx_n_s_ovr, __pyx_n_s_keep, __pyx_n_s_ovr1, __pyx_n_s_ovr2); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 70, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__34);
+  __Pyx_GIVEREF(__pyx_tuple__34);
+  __pyx_codeobj__35 = (PyObject*)__Pyx_PyCode_New(2, 0, 31, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__34, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_yjr_PycharmProjects_Faster, __pyx_n_s_nms_new, 70, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__35)) __PYX_ERR(0, 70, __pyx_L1_error)
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+
+static int __Pyx_InitGlobals(void) {
+  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+  __pyx_float_0_95 = PyFloat_FromDouble(0.95); if (unlikely(!__pyx_float_0_95)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_4 = PyInt_FromLong(4); if (unlikely(!__pyx_int_4)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  return 0;
+  __pyx_L1_error:;
+  return -1;
+}
+
+#if PY_MAJOR_VERSION < 3
+PyMODINIT_FUNC initcython_nms(void); /*proto*/
+PyMODINIT_FUNC initcython_nms(void)
+#else
+PyMODINIT_FUNC PyInit_cython_nms(void); /*proto*/
+PyMODINIT_FUNC PyInit_cython_nms(void)
+#endif
+{
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannyDeclarations
+  #if CYTHON_REFNANNY
+  __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
+  if (!__Pyx_RefNanny) {
+      PyErr_Clear();
+      __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny");
+      if (!__Pyx_RefNanny)
+          Py_FatalError("failed to import 'refnanny' module");
+  }
+  #endif
+  __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_cython_nms(void)", 0);
+  if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #ifdef __Pyx_CyFunction_USED
+  if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_Generator_USED
+  if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_StopAsyncIteration_USED
+  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  /*--- Library function declarations ---*/
+  /*--- Threads initialization code ---*/
+  #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
+  #ifdef WITH_THREAD /* Python build with threading support? */
+  PyEval_InitThreads();
+  #endif
+  #endif
+  /*--- Module creation code ---*/
+  #if PY_MAJOR_VERSION < 3
+  __pyx_m = Py_InitModule4("cython_nms", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
+  #else
+  __pyx_m = PyModule_Create(&__pyx_moduledef);
+  #endif
+  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
+  Py_INCREF(__pyx_d);
+  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #if CYTHON_COMPILING_IN_PYPY
+  Py_INCREF(__pyx_b);
+  #endif
+  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+  /*--- Initialize various global constants etc. ---*/
+  if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
+  if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  if (__pyx_module_is_main_cython_nms) {
+    if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  }
+  #if PY_MAJOR_VERSION >= 3
+  {
+    PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
+    if (!PyDict_GetItemString(modules, "cython_nms")) {
+      if (unlikely(PyDict_SetItemString(modules, "cython_nms", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+    }
+  }
+  #endif
+  /*--- Builtin init code ---*/
+  if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  /*--- Constants init code ---*/
+  if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  /*--- Global init code ---*/
+  /*--- Variable export code ---*/
+  /*--- Function export code ---*/
+  /*--- Type init code ---*/
+  /*--- Type import code ---*/
+  __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "type", 
+  #if CYTHON_COMPILING_IN_PYPY
+  sizeof(PyTypeObject),
+  #else
+  sizeof(PyHeapTypeObject),
+  #endif
+  0); if (unlikely(!__pyx_ptype_7cpython_4type_type)) __PYX_ERR(2, 9, __pyx_L1_error)
+  __pyx_ptype_5numpy_dtype = __Pyx_ImportType("numpy", "dtype", sizeof(PyArray_Descr), 0); if (unlikely(!__pyx_ptype_5numpy_dtype)) __PYX_ERR(1, 155, __pyx_L1_error)
+  __pyx_ptype_5numpy_flatiter = __Pyx_ImportType("numpy", "flatiter", sizeof(PyArrayIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_flatiter)) __PYX_ERR(1, 168, __pyx_L1_error)
+  __pyx_ptype_5numpy_broadcast = __Pyx_ImportType("numpy", "broadcast", sizeof(PyArrayMultiIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_broadcast)) __PYX_ERR(1, 172, __pyx_L1_error)
+  __pyx_ptype_5numpy_ndarray = __Pyx_ImportType("numpy", "ndarray", sizeof(PyArrayObject), 0); if (unlikely(!__pyx_ptype_5numpy_ndarray)) __PYX_ERR(1, 181, __pyx_L1_error)
+  __pyx_ptype_5numpy_ufunc = __Pyx_ImportType("numpy", "ufunc", sizeof(PyUFuncObject), 0); if (unlikely(!__pyx_ptype_5numpy_ufunc)) __PYX_ERR(1, 861, __pyx_L1_error)
+  /*--- Variable import code ---*/
+  /*--- Function import code ---*/
+  /*--- Execution code ---*/
+  #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
+  if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+
+  /* "nms.pyx":8
+ * # --------------------------------------------------------
+ * 
+ * import numpy as np             # <<<<<<<<<<<<<<
+ * cimport numpy as np
+ * 
+ */
+  __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "nms.pyx":17
+ *     return a if a <= b else b
+ * 
+ * def nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ */
+  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_10cython_nms_1nms, NULL, __pyx_n_s_cython_nms); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_nms, __pyx_t_1) < 0) __PYX_ERR(0, 17, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "nms.pyx":70
+ *     return keep
+ * 
+ * def nms_new(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):             # <<<<<<<<<<<<<<
+ *     cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]
+ *     cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ */
+  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_10cython_nms_3nms_new, NULL, __pyx_n_s_cython_nms); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 70, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_nms_new, __pyx_t_1) < 0) __PYX_ERR(0, 70, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "nms.pyx":1
+ * # --------------------------------------------------------             # <<<<<<<<<<<<<<
+ * # Fast R-CNN
+ * # Copyright (c) 2015 Microsoft
+ */
+  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "../../../../../softWares/anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":997
+ *         raise ImportError("numpy.core.umath failed to import")
+ * 
+ * cdef inline int import_ufunc() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_umath()
+ */
+
+  /*--- Wrapped vars code ---*/
+
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  if (__pyx_m) {
+    if (__pyx_d) {
+      __Pyx_AddTraceback("init cython_nms", __pyx_clineno, __pyx_lineno, __pyx_filename);
+    }
+    Py_DECREF(__pyx_m); __pyx_m = 0;
+  } else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_ImportError, "init cython_nms");
+  }
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  #if PY_MAJOR_VERSION < 3
+  return;
+  #else
+  return __pyx_m;
+  #endif
+}
+
+/* --- Runtime support code --- */
+/* Refnanny */
+#if CYTHON_REFNANNY
+static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
+    PyObject *m = NULL, *p = NULL;
+    void *r = NULL;
+    m = PyImport_ImportModule((char *)modname);
+    if (!m) goto end;
+    p = PyObject_GetAttrString(m, (char *)"RefNannyAPI");
+    if (!p) goto end;
+    r = PyLong_AsVoidPtr(p);
+end:
+    Py_XDECREF(p);
+    Py_XDECREF(m);
+    return (__Pyx_RefNannyAPIStruct *)r;
+}
+#endif
+
+/* GetBuiltinName */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
+    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
+    if (unlikely(!result)) {
+        PyErr_Format(PyExc_NameError,
+#if PY_MAJOR_VERSION >= 3
+            "name '%U' is not defined", name);
+#else
+            "name '%.200s' is not defined", PyString_AS_STRING(name));
+#endif
+    }
+    return result;
+}
+
+/* RaiseArgTupleInvalid */
+static void __Pyx_RaiseArgtupleInvalid(
+    const char* func_name,
+    int exact,
+    Py_ssize_t num_min,
+    Py_ssize_t num_max,
+    Py_ssize_t num_found)
+{
+    Py_ssize_t num_expected;
+    const char *more_or_less;
+    if (num_found < num_min) {
+        num_expected = num_min;
+        more_or_less = "at least";
+    } else {
+        num_expected = num_max;
+        more_or_less = "at most";
+    }
+    if (exact) {
+        more_or_less = "exactly";
+    }
+    PyErr_Format(PyExc_TypeError,
+                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                 func_name, more_or_less, num_expected,
+                 (num_expected == 1) ? "" : "s", num_found);
+}
+
+/* RaiseDoubleKeywords */
+static void __Pyx_RaiseDoubleKeywordsError(
+    const char* func_name,
+    PyObject* kw_name)
+{
+    PyErr_Format(PyExc_TypeError,
+        #if PY_MAJOR_VERSION >= 3
+        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
+        #else
+        "%s() got multiple values for keyword argument '%s'", func_name,
+        PyString_AsString(kw_name));
+        #endif
+}
+
+/* ParseKeywords */
+static int __Pyx_ParseOptionalKeywords(
+    PyObject *kwds,
+    PyObject **argnames[],
+    PyObject *kwds2,
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    const char* function_name)
+{
+    PyObject *key = 0, *value = 0;
+    Py_ssize_t pos = 0;
+    PyObject*** name;
+    PyObject*** first_kw_arg = argnames + num_pos_args;
+    while (PyDict_Next(kwds, &pos, &key, &value)) {
+        name = first_kw_arg;
+        while (*name && (**name != key)) name++;
+        if (*name) {
+            values[name-argnames] = value;
+            continue;
+        }
+        name = first_kw_arg;
+        #if PY_MAJOR_VERSION < 3
+        if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) {
+            while (*name) {
+                if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
+                        && _PyString_Eq(**name, key)) {
+                    values[name-argnames] = value;
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    if ((**argname == key) || (
+                            (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))
+                             && _PyString_Eq(**argname, key))) {
+                        goto arg_passed_twice;
+                    }
+                    argname++;
+                }
+            }
+        } else
+        #endif
+        if (likely(PyUnicode_Check(key))) {
+            while (*name) {
+                int cmp = (**name == key) ? 0 :
+                #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+                    (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 :
+                #endif
+                    PyUnicode_Compare(**name, key);
+                if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                if (cmp == 0) {
+                    values[name-argnames] = value;
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    int cmp = (**argname == key) ? 0 :
+                    #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+                        (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 :
+                    #endif
+                        PyUnicode_Compare(**argname, key);
+                    if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                    if (cmp == 0) goto arg_passed_twice;
+                    argname++;
+                }
+            }
+        } else
+            goto invalid_keyword_type;
+        if (kwds2) {
+            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
+        } else {
+            goto invalid_keyword;
+        }
+    }
+    return 0;
+arg_passed_twice:
+    __Pyx_RaiseDoubleKeywordsError(function_name, key);
+    goto bad;
+invalid_keyword_type:
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() keywords must be strings", function_name);
+    goto bad;
+invalid_keyword:
+    PyErr_Format(PyExc_TypeError,
+    #if PY_MAJOR_VERSION < 3
+        "%.200s() got an unexpected keyword argument '%.200s'",
+        function_name, PyString_AsString(key));
+    #else
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    #endif
+bad:
+    return -1;
+}
+
+/* ArgTypeTest */
+static void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) {
+    PyErr_Format(PyExc_TypeError,
+        "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)",
+        name, type->tp_name, Py_TYPE(obj)->tp_name);
+}
+static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,
+    const char *name, int exact)
+{
+    if (unlikely(!type)) {
+        PyErr_SetString(PyExc_SystemError, "Missing type object");
+        return 0;
+    }
+    if (none_allowed && obj == Py_None) return 1;
+    else if (exact) {
+        if (likely(Py_TYPE(obj) == type)) return 1;
+        #if PY_MAJOR_VERSION == 2
+        else if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1;
+        #endif
+    }
+    else {
+        if (likely(PyObject_TypeCheck(obj, type))) return 1;
+    }
+    __Pyx_RaiseArgumentTypeInvalid(name, obj, type);
+    return 0;
+}
+
+/* BufferFormatCheck */
+static CYTHON_INLINE int __Pyx_IsLittleEndian(void) {
+  unsigned int n = 1;
+  return *(unsigned char*)(&n) != 0;
+}
+static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,
+                              __Pyx_BufFmt_StackElem* stack,
+                              __Pyx_TypeInfo* type) {
+  stack[0].field = &ctx->root;
+  stack[0].parent_offset = 0;
+  ctx->root.type = type;
+  ctx->root.name = "buffer dtype";
+  ctx->root.offset = 0;
+  ctx->head = stack;
+  ctx->head->field = &ctx->root;
+  ctx->fmt_offset = 0;
+  ctx->head->parent_offset = 0;
+  ctx->new_packmode = '@';
+  ctx->enc_packmode = '@';
+  ctx->new_count = 1;
+  ctx->enc_count = 0;
+  ctx->enc_type = 0;
+  ctx->is_complex = 0;
+  ctx->is_valid_array = 0;
+  ctx->struct_alignment = 0;
+  while (type->typegroup == 'S') {
+    ++ctx->head;
+    ctx->head->field = type->fields;
+    ctx->head->parent_offset = 0;
+    type = type->fields->type;
+  }
+}
+static int __Pyx_BufFmt_ParseNumber(const char** ts) {
+    int count;
+    const char* t = *ts;
+    if (*t < '0' || *t > '9') {
+      return -1;
+    } else {
+        count = *t++ - '0';
+        while (*t >= '0' && *t < '9') {
+            count *= 10;
+            count += *t++ - '0';
+        }
+    }
+    *ts = t;
+    return count;
+}
+static int __Pyx_BufFmt_ExpectNumber(const char **ts) {
+    int number = __Pyx_BufFmt_ParseNumber(ts);
+    if (number == -1)
+        PyErr_Format(PyExc_ValueError,\
+                     "Does not understand character buffer dtype format string ('%c')", **ts);
+    return number;
+}
+static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) {
+  PyErr_Format(PyExc_ValueError,
+               "Unexpected format string character: '%c'", ch);
+}
+static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) {
+  switch (ch) {
+    case 'c': return "'char'";
+    case 'b': return "'signed char'";
+    case 'B': return "'unsigned char'";
+    case 'h': return "'short'";
+    case 'H': return "'unsigned short'";
+    case 'i': return "'int'";
+    case 'I': return "'unsigned int'";
+    case 'l': return "'long'";
+    case 'L': return "'unsigned long'";
+    case 'q': return "'long long'";
+    case 'Q': return "'unsigned long long'";
+    case 'f': return (is_complex ? "'complex float'" : "'float'");
+    case 'd': return (is_complex ? "'complex double'" : "'double'");
+    case 'g': return (is_complex ? "'complex long double'" : "'long double'");
+    case 'T': return "a struct";
+    case 'O': return "Python object";
+    case 'P': return "a pointer";
+    case 's': case 'p': return "a string";
+    case 0: return "end";
+    default: return "unparseable format string";
+  }
+}
+static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) {
+  switch (ch) {
+    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
+    case 'h': case 'H': return 2;
+    case 'i': case 'I': case 'l': case 'L': return 4;
+    case 'q': case 'Q': return 8;
+    case 'f': return (is_complex ? 8 : 4);
+    case 'd': return (is_complex ? 16 : 8);
+    case 'g': {
+      PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g')..");
+      return 0;
+    }
+    case 'O': case 'P': return sizeof(void*);
+    default:
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+}
+static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) {
+  switch (ch) {
+    case 'c': case 'b': case 'B': case 's': case 'p': return 1;
+    case 'h': case 'H': return sizeof(short);
+    case 'i': case 'I': return sizeof(int);
+    case 'l': case 'L': return sizeof(long);
+    #ifdef HAVE_LONG_LONG
+    case 'q': case 'Q': return sizeof(PY_LONG_LONG);
+    #endif
+    case 'f': return sizeof(float) * (is_complex ? 2 : 1);
+    case 'd': return sizeof(double) * (is_complex ? 2 : 1);
+    case 'g': return sizeof(long double) * (is_complex ? 2 : 1);
+    case 'O': case 'P': return sizeof(void*);
+    default: {
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+  }
+}
+typedef struct { char c; short x; } __Pyx_st_short;
+typedef struct { char c; int x; } __Pyx_st_int;
+typedef struct { char c; long x; } __Pyx_st_long;
+typedef struct { char c; float x; } __Pyx_st_float;
+typedef struct { char c; double x; } __Pyx_st_double;
+typedef struct { char c; long double x; } __Pyx_st_longdouble;
+typedef struct { char c; void *x; } __Pyx_st_void_p;
+#ifdef HAVE_LONG_LONG
+typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong;
+#endif
+static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) {
+  switch (ch) {
+    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
+    case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short);
+    case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int);
+    case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long);
+#ifdef HAVE_LONG_LONG
+    case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG);
+#endif
+    case 'f': return sizeof(__Pyx_st_float) - sizeof(float);
+    case 'd': return sizeof(__Pyx_st_double) - sizeof(double);
+    case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double);
+    case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*);
+    default:
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+}
+/* These are for computing the padding at the end of the struct to align
+   on the first member of the struct. This will probably the same as above,
+   but we don't have any guarantees.
+ */
+typedef struct { short x; char c; } __Pyx_pad_short;
+typedef struct { int x; char c; } __Pyx_pad_int;
+typedef struct { long x; char c; } __Pyx_pad_long;
+typedef struct { float x; char c; } __Pyx_pad_float;
+typedef struct { double x; char c; } __Pyx_pad_double;
+typedef struct { long double x; char c; } __Pyx_pad_longdouble;
+typedef struct { void *x; char c; } __Pyx_pad_void_p;
+#ifdef HAVE_LONG_LONG
+typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong;
+#endif
+static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) {
+  switch (ch) {
+    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
+    case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short);
+    case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int);
+    case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long);
+#ifdef HAVE_LONG_LONG
+    case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG);
+#endif
+    case 'f': return sizeof(__Pyx_pad_float) - sizeof(float);
+    case 'd': return sizeof(__Pyx_pad_double) - sizeof(double);
+    case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double);
+    case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*);
+    default:
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+}
+static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) {
+  switch (ch) {
+    case 'c':
+        return 'H';
+    case 'b': case 'h': case 'i':
+    case 'l': case 'q': case 's': case 'p':
+        return 'I';
+    case 'B': case 'H': case 'I': case 'L': case 'Q':
+        return 'U';
+    case 'f': case 'd': case 'g':
+        return (is_complex ? 'C' : 'R');
+    case 'O':
+        return 'O';
+    case 'P':
+        return 'P';
+    default: {
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+  }
+}
+static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) {
+  if (ctx->head == NULL || ctx->head->field == &ctx->root) {
+    const char* expected;
+    const char* quote;
+    if (ctx->head == NULL) {
+      expected = "end";
+      quote = "";
+    } else {
+      expected = ctx->head->field->type->name;
+      quote = "'";
+    }
+    PyErr_Format(PyExc_ValueError,
+                 "Buffer dtype mismatch, expected %s%s%s but got %s",
+                 quote, expected, quote,
+                 __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex));
+  } else {
+    __Pyx_StructField* field = ctx->head->field;
+    __Pyx_StructField* parent = (ctx->head - 1)->field;
+    PyErr_Format(PyExc_ValueError,
+                 "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'",
+                 field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex),
+                 parent->type->name, field->name);
+  }
+}
+static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) {
+  char group;
+  size_t size, offset, arraysize = 1;
+  if (ctx->enc_type == 0) return 0;
+  if (ctx->head->field->type->arraysize[0]) {
+    int i, ndim = 0;
+    if (ctx->enc_type == 's' || ctx->enc_type == 'p') {
+        ctx->is_valid_array = ctx->head->field->type->ndim == 1;
+        ndim = 1;
+        if (ctx->enc_count != ctx->head->field->type->arraysize[0]) {
+            PyErr_Format(PyExc_ValueError,
+                         "Expected a dimension of size %zu, got %zu",
+                         ctx->head->field->type->arraysize[0], ctx->enc_count);
+            return -1;
+        }
+    }
+    if (!ctx->is_valid_array) {
+      PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d",
+                   ctx->head->field->type->ndim, ndim);
+      return -1;
+    }
+    for (i = 0; i < ctx->head->field->type->ndim; i++) {
+      arraysize *= ctx->head->field->type->arraysize[i];
+    }
+    ctx->is_valid_array = 0;
+    ctx->enc_count = 1;
+  }
+  group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex);
+  do {
+    __Pyx_StructField* field = ctx->head->field;
+    __Pyx_TypeInfo* type = field->type;
+    if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') {
+      size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex);
+    } else {
+      size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex);
+    }
+    if (ctx->enc_packmode == '@') {
+      size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex);
+      size_t align_mod_offset;
+      if (align_at == 0) return -1;
+      align_mod_offset = ctx->fmt_offset % align_at;
+      if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset;
+      if (ctx->struct_alignment == 0)
+          ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type,
+                                                                 ctx->is_complex);
+    }
+    if (type->size != size || type->typegroup != group) {
+      if (type->typegroup == 'C' && type->fields != NULL) {
+        size_t parent_offset = ctx->head->parent_offset + field->offset;
+        ++ctx->head;
+        ctx->head->field = type->fields;
+        ctx->head->parent_offset = parent_offset;
+        continue;
+      }
+      if ((type->typegroup == 'H' || group == 'H') && type->size == size) {
+      } else {
+          __Pyx_BufFmt_RaiseExpected(ctx);
+          return -1;
+      }
+    }
+    offset = ctx->head->parent_offset + field->offset;
+    if (ctx->fmt_offset != offset) {
+      PyErr_Format(PyExc_ValueError,
+                   "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected",
+                   (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset);
+      return -1;
+    }
+    ctx->fmt_offset += size;
+    if (arraysize)
+      ctx->fmt_offset += (arraysize - 1) * size;
+    --ctx->enc_count;
+    while (1) {
+      if (field == &ctx->root) {
+        ctx->head = NULL;
+        if (ctx->enc_count != 0) {
+          __Pyx_BufFmt_RaiseExpected(ctx);
+          return -1;
+        }
+        break;
+      }
+      ctx->head->field = ++field;
+      if (field->type == NULL) {
+        --ctx->head;
+        field = ctx->head->field;
+        continue;
+      } else if (field->type->typegroup == 'S') {
+        size_t parent_offset = ctx->head->parent_offset + field->offset;
+        if (field->type->fields->type == NULL) continue;
+        field = field->type->fields;
+        ++ctx->head;
+        ctx->head->field = field;
+        ctx->head->parent_offset = parent_offset;
+        break;
+      } else {
+        break;
+      }
+    }
+  } while (ctx->enc_count);
+  ctx->enc_type = 0;
+  ctx->is_complex = 0;
+  return 0;
+}
+static CYTHON_INLINE PyObject *
+__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp)
+{
+    const char *ts = *tsp;
+    int i = 0, number;
+    int ndim = ctx->head->field->type->ndim;
+;
+    ++ts;
+    if (ctx->new_count != 1) {
+        PyErr_SetString(PyExc_ValueError,
+                        "Cannot handle repeated arrays in format string");
+        return NULL;
+    }
+    if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+    while (*ts && *ts != ')') {
+        switch (*ts) {
+            case ' ': case '\f': case '\r': case '\n': case '\t': case '\v':  continue;
+            default:  break;
+        }
+        number = __Pyx_BufFmt_ExpectNumber(&ts);
+        if (number == -1) return NULL;
+        if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i])
+            return PyErr_Format(PyExc_ValueError,
+                        "Expected a dimension of size %zu, got %d",
+                        ctx->head->field->type->arraysize[i], number);
+        if (*ts != ',' && *ts != ')')
+            return PyErr_Format(PyExc_ValueError,
+                                "Expected a comma in format string, got '%c'", *ts);
+        if (*ts == ',') ts++;
+        i++;
+    }
+    if (i != ndim)
+        return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d",
+                            ctx->head->field->type->ndim, i);
+    if (!*ts) {
+        PyErr_SetString(PyExc_ValueError,
+                        "Unexpected end of format string, expected ')'");
+        return NULL;
+    }
+    ctx->is_valid_array = 1;
+    ctx->new_count = 1;
+    *tsp = ++ts;
+    return Py_None;
+}
+static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) {
+  int got_Z = 0;
+  while (1) {
+    switch(*ts) {
+      case 0:
+        if (ctx->enc_type != 0 && ctx->head == NULL) {
+          __Pyx_BufFmt_RaiseExpected(ctx);
+          return NULL;
+        }
+        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+        if (ctx->head != NULL) {
+          __Pyx_BufFmt_RaiseExpected(ctx);
+          return NULL;
+        }
+        return ts;
+      case ' ':
+      case '\r':
+      case '\n':
+        ++ts;
+        break;
+      case '<':
+        if (!__Pyx_IsLittleEndian()) {
+          PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler");
+          return NULL;
+        }
+        ctx->new_packmode = '=';
+        ++ts;
+        break;
+      case '>':
+      case '!':
+        if (__Pyx_IsLittleEndian()) {
+          PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler");
+          return NULL;
+        }
+        ctx->new_packmode = '=';
+        ++ts;
+        break;
+      case '=':
+      case '@':
+      case '^':
+        ctx->new_packmode = *ts++;
+        break;
+      case 'T':
+        {
+          const char* ts_after_sub;
+          size_t i, struct_count = ctx->new_count;
+          size_t struct_alignment = ctx->struct_alignment;
+          ctx->new_count = 1;
+          ++ts;
+          if (*ts != '{') {
+            PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'");
+            return NULL;
+          }
+          if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+          ctx->enc_type = 0;
+          ctx->enc_count = 0;
+          ctx->struct_alignment = 0;
+          ++ts;
+          ts_after_sub = ts;
+          for (i = 0; i != struct_count; ++i) {
+            ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts);
+            if (!ts_after_sub) return NULL;
+          }
+          ts = ts_after_sub;
+          if (struct_alignment) ctx->struct_alignment = struct_alignment;
+        }
+        break;
+      case '}':
+        {
+          size_t alignment = ctx->struct_alignment;
+          ++ts;
+          if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+          ctx->enc_type = 0;
+          if (alignment && ctx->fmt_offset % alignment) {
+            ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment);
+          }
+        }
+        return ts;
+      case 'x':
+        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+        ctx->fmt_offset += ctx->new_count;
+        ctx->new_count = 1;
+        ctx->enc_count = 0;
+        ctx->enc_type = 0;
+        ctx->enc_packmode = ctx->new_packmode;
+        ++ts;
+        break;
+      case 'Z':
+        got_Z = 1;
+        ++ts;
+        if (*ts != 'f' && *ts != 'd' && *ts != 'g') {
+          __Pyx_BufFmt_RaiseUnexpectedChar('Z');
+          return NULL;
+        }
+      case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I':
+      case 'l': case 'L': case 'q': case 'Q':
+      case 'f': case 'd': case 'g':
+      case 'O': case 'p':
+        if (ctx->enc_type == *ts && got_Z == ctx->is_complex &&
+            ctx->enc_packmode == ctx->new_packmode) {
+          ctx->enc_count += ctx->new_count;
+          ctx->new_count = 1;
+          got_Z = 0;
+          ++ts;
+          break;
+        }
+      case 's':
+        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+        ctx->enc_count = ctx->new_count;
+        ctx->enc_packmode = ctx->new_packmode;
+        ctx->enc_type = *ts;
+        ctx->is_complex = got_Z;
+        ++ts;
+        ctx->new_count = 1;
+        got_Z = 0;
+        break;
+      case ':':
+        ++ts;
+        while(*ts != ':') ++ts;
+        ++ts;
+        break;
+      case '(':
+        if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL;
+        break;
+      default:
+        {
+          int number = __Pyx_BufFmt_ExpectNumber(&ts);
+          if (number == -1) return NULL;
+          ctx->new_count = (size_t)number;
+        }
+    }
+  }
+}
+static CYTHON_INLINE void __Pyx_ZeroBuffer(Py_buffer* buf) {
+  buf->buf = NULL;
+  buf->obj = NULL;
+  buf->strides = __Pyx_zeros;
+  buf->shape = __Pyx_zeros;
+  buf->suboffsets = __Pyx_minusones;
+}
+static CYTHON_INLINE int __Pyx_GetBufferAndValidate(
+        Py_buffer* buf, PyObject* obj,  __Pyx_TypeInfo* dtype, int flags,
+        int nd, int cast, __Pyx_BufFmt_StackElem* stack)
+{
+  if (obj == Py_None || obj == NULL) {
+    __Pyx_ZeroBuffer(buf);
+    return 0;
+  }
+  buf->buf = NULL;
+  if (__Pyx_GetBuffer(obj, buf, flags) == -1) goto fail;
+  if (buf->ndim != nd) {
+    PyErr_Format(PyExc_ValueError,
+                 "Buffer has wrong number of dimensions (expected %d, got %d)",
+                 nd, buf->ndim);
+    goto fail;
+  }
+  if (!cast) {
+    __Pyx_BufFmt_Context ctx;
+    __Pyx_BufFmt_Init(&ctx, stack, dtype);
+    if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail;
+  }
+  if ((unsigned)buf->itemsize != dtype->size) {
+    PyErr_Format(PyExc_ValueError,
+      "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)",
+      buf->itemsize, (buf->itemsize > 1) ? "s" : "",
+      dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : "");
+    goto fail;
+  }
+  if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones;
+  return 0;
+fail:;
+  __Pyx_ZeroBuffer(buf);
+  return -1;
+}
+static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) {
+  if (info->buf == NULL) return;
+  if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL;
+  __Pyx_ReleaseBuffer(info);
+}
+
+/* ExtTypeTest */
+  static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
+    if (unlikely(!type)) {
+        PyErr_SetString(PyExc_SystemError, "Missing type object");
+        return 0;
+    }
+    if (likely(PyObject_TypeCheck(obj, type)))
+        return 1;
+    PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s",
+                 Py_TYPE(obj)->tp_name, type->tp_name);
+    return 0;
+}
+
+/* PyIntBinop */
+  #if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) {
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact(op1))) {
+        const long b = intval;
+        long x;
+        long a = PyInt_AS_LONG(op1);
+            x = (long)((unsigned long)a + b);
+            if (likely((x^a) >= 0 || (x^b) >= 0))
+                return PyInt_FromLong(x);
+            return PyLong_Type.tp_as_number->nb_add(op1, op2);
+    }
+    #endif
+    #if CYTHON_USE_PYLONG_INTERNALS
+    if (likely(PyLong_CheckExact(op1))) {
+        const long b = intval;
+        long a, x;
+#ifdef HAVE_LONG_LONG
+        const PY_LONG_LONG llb = intval;
+        PY_LONG_LONG lla, llx;
+#endif
+        const digit* digits = ((PyLongObject*)op1)->ob_digit;
+        const Py_ssize_t size = Py_SIZE(op1);
+        if (likely(__Pyx_sst_abs(size) <= 1)) {
+            a = likely(size) ? digits[0] : 0;
+            if (size == -1) a = -a;
+        } else {
+            switch (size) {
+                case -2:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                case 2:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                case -3:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                case 3:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                case -4:
+                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                case 4:
+                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                default: return PyLong_Type.tp_as_number->nb_add(op1, op2);
+            }
+        }
+                x = a + b;
+            return PyLong_FromLong(x);
+#ifdef HAVE_LONG_LONG
+        long_long:
+                llx = lla + llb;
+            return PyLong_FromLongLong(llx);
+#endif
+        
+        
+    }
+    #endif
+    if (PyFloat_CheckExact(op1)) {
+        const long b = intval;
+        double a = PyFloat_AS_DOUBLE(op1);
+            double result;
+            PyFPE_START_PROTECT("add", return NULL)
+            result = ((double)a) + (double)b;
+            PyFPE_END_PROTECT(result)
+            return PyFloat_FromDouble(result);
+    }
+    return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2);
+}
+#endif
+
+/* PyCFunctionFastCall */
+  #if CYTHON_FAST_PYCCALL
+static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) {
+    PyCFunctionObject *func = (PyCFunctionObject*)func_obj;
+    PyCFunction meth = PyCFunction_GET_FUNCTION(func);
+    PyObject *self = PyCFunction_GET_SELF(func);
+    assert(PyCFunction_Check(func));
+    assert(METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST)));
+    assert(nargs >= 0);
+    assert(nargs == 0 || args != NULL);
+    /* _PyCFunction_FastCallDict() must not be called with an exception set,
+       because it may clear it (directly or indirectly) and so the
+       caller loses its exception */
+    assert(!PyErr_Occurred());
+    return (*((__Pyx_PyCFunctionFast)meth)) (self, args, nargs, NULL);
+}
+#endif  // CYTHON_FAST_PYCCALL
+
+/* PyFunctionFastCall */
+  #if CYTHON_FAST_PYCALL
+#include "frameobject.h"
+static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
+                                               PyObject *globals) {
+    PyFrameObject *f;
+    PyThreadState *tstate = PyThreadState_GET();
+    PyObject **fastlocals;
+    Py_ssize_t i;
+    PyObject *result;
+    assert(globals != NULL);
+    /* XXX Perhaps we should create a specialized
+       PyFrame_New() that doesn't take locals, but does
+       take builtins without sanity checking them.
+       */
+    assert(tstate != NULL);
+    f = PyFrame_New(tstate, co, globals, NULL);
+    if (f == NULL) {
+        return NULL;
+    }
+    fastlocals = f->f_localsplus;
+    for (i = 0; i < na; i++) {
+        Py_INCREF(*args);
+        fastlocals[i] = *args++;
+    }
+    result = PyEval_EvalFrameEx(f,0);
+    ++tstate->recursion_depth;
+    Py_DECREF(f);
+    --tstate->recursion_depth;
+    return result;
+}
+#if 1 || PY_VERSION_HEX < 0x030600B1
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs) {
+    PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
+    PyObject *globals = PyFunction_GET_GLOBALS(func);
+    PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
+    PyObject *closure;
+#if PY_MAJOR_VERSION >= 3
+    PyObject *kwdefs;
+#endif
+    PyObject *kwtuple, **k;
+    PyObject **d;
+    Py_ssize_t nd;
+    Py_ssize_t nk;
+    PyObject *result;
+    assert(kwargs == NULL || PyDict_Check(kwargs));
+    nk = kwargs ? PyDict_Size(kwargs) : 0;
+    if (Py_EnterRecursiveCall((char*)" while calling a Python object")) {
+        return NULL;
+    }
+    if (
+#if PY_MAJOR_VERSION >= 3
+            co->co_kwonlyargcount == 0 &&
+#endif
+            likely(kwargs == NULL || nk == 0) &&
+            co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
+        if (argdefs == NULL && co->co_argcount == nargs) {
+            result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals);
+            goto done;
+        }
+        else if (nargs == 0 && argdefs != NULL
+                 && co->co_argcount == Py_SIZE(argdefs)) {
+            /* function called with no arguments, but all parameters have
+               a default value: use default values as arguments .*/
+            args = &PyTuple_GET_ITEM(argdefs, 0);
+            result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals);
+            goto done;
+        }
+    }
+    if (kwargs != NULL) {
+        Py_ssize_t pos, i;
+        kwtuple = PyTuple_New(2 * nk);
+        if (kwtuple == NULL) {
+            result = NULL;
+            goto done;
+        }
+        k = &PyTuple_GET_ITEM(kwtuple, 0);
+        pos = i = 0;
+        while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) {
+            Py_INCREF(k[i]);
+            Py_INCREF(k[i+1]);
+            i += 2;
+        }
+        nk = i / 2;
+    }
+    else {
+        kwtuple = NULL;
+        k = NULL;
+    }
+    closure = PyFunction_GET_CLOSURE(func);
+#if PY_MAJOR_VERSION >= 3
+    kwdefs = PyFunction_GET_KW_DEFAULTS(func);
+#endif
+    if (argdefs != NULL) {
+        d = &PyTuple_GET_ITEM(argdefs, 0);
+        nd = Py_SIZE(argdefs);
+    }
+    else {
+        d = NULL;
+        nd = 0;
+    }
+#if PY_MAJOR_VERSION >= 3
+    result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL,
+                               args, nargs,
+                               k, (int)nk,
+                               d, (int)nd, kwdefs, closure);
+#else
+    result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL,
+                               args, nargs,
+                               k, (int)nk,
+                               d, (int)nd, closure);
+#endif
+    Py_XDECREF(kwtuple);
+done:
+    Py_LeaveRecursiveCall();
+    return result;
+}
+#endif  // CPython < 3.6
+#endif  // CYTHON_FAST_PYCALL
+
+/* PyObjectCall */
+  #if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *result;
+    ternaryfunc call = func->ob_type->tp_call;
+    if (unlikely(!call))
+        return PyObject_Call(func, arg, kw);
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    result = (*call)(func, arg, kw);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
+#endif
+
+/* PyObjectCallMethO */
+  #if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
+    PyObject *self, *result;
+    PyCFunction cfunc;
+    cfunc = PyCFunction_GET_FUNCTION(func);
+    self = PyCFunction_GET_SELF(func);
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    result = cfunc(self, arg);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
+#endif
+
+/* PyObjectCallOneArg */
+  #if CYTHON_COMPILING_IN_CPYTHON
+static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+    PyObject *result;
+    PyObject *args = PyTuple_New(1);
+    if (unlikely(!args)) return NULL;
+    Py_INCREF(arg);
+    PyTuple_SET_ITEM(args, 0, arg);
+    result = __Pyx_PyObject_Call(func, args, NULL);
+    Py_DECREF(args);
+    return result;
+}
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+#if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(func)) {
+        return __Pyx_PyFunction_FastCall(func, &arg, 1);
+    }
+#endif
+#ifdef __Pyx_CyFunction_USED
+    if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) {
+#else
+    if (likely(PyCFunction_Check(func))) {
+#endif
+        if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) {
+            return __Pyx_PyObject_CallMethO(func, arg);
+#if CYTHON_FAST_PYCCALL
+        } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) {
+            return __Pyx_PyCFunction_FastCall(func, &arg, 1);
+#endif
+        }
+    }
+    return __Pyx__PyObject_CallOneArg(func, arg);
+}
+#else
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+    PyObject *result;
+    PyObject *args = PyTuple_Pack(1, arg);
+    if (unlikely(!args)) return NULL;
+    result = __Pyx_PyObject_Call(func, args, NULL);
+    Py_DECREF(args);
+    return result;
+}
+#endif
+
+/* PyObjectCallNoArg */
+    #if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
+#if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(func)) {
+        return __Pyx_PyFunction_FastCall(func, NULL, 0);
+    }
+#endif
+#ifdef __Pyx_CyFunction_USED
+    if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) {
+#else
+    if (likely(PyCFunction_Check(func))) {
+#endif
+        if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) {
+            return __Pyx_PyObject_CallMethO(func, NULL);
+        }
+    }
+    return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL);
+}
+#endif
+
+/* GetModuleGlobalName */
+      static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) {
+    PyObject *result;
+#if !CYTHON_AVOID_BORROWED_REFS
+    result = PyDict_GetItem(__pyx_d, name);
+    if (likely(result)) {
+        Py_INCREF(result);
+    } else {
+#else
+    result = PyObject_GetItem(__pyx_d, name);
+    if (!result) {
+        PyErr_Clear();
+#endif
+        result = __Pyx_GetBuiltinName(name);
+    }
+    return result;
+}
+
+/* BufferIndexError */
+        static void __Pyx_RaiseBufferIndexError(int axis) {
+  PyErr_Format(PyExc_IndexError,
+     "Out of bounds on buffer access (axis %d)", axis);
+}
+
+/* PyErrFetchRestore */
+        #if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->curexc_type;
+    tmp_value = tstate->curexc_value;
+    tmp_tb = tstate->curexc_traceback;
+    tstate->curexc_type = type;
+    tstate->curexc_value = value;
+    tstate->curexc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+}
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+    *type = tstate->curexc_type;
+    *value = tstate->curexc_value;
+    *tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+}
+#endif
+
+/* RaiseException */
+        #if PY_MAJOR_VERSION < 3
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
+                        CYTHON_UNUSED PyObject *cause) {
+    __Pyx_PyThreadState_declare
+    Py_XINCREF(type);
+    if (!value || value == Py_None)
+        value = NULL;
+    else
+        Py_INCREF(value);
+    if (!tb || tb == Py_None)
+        tb = NULL;
+    else {
+        Py_INCREF(tb);
+        if (!PyTraceBack_Check(tb)) {
+            PyErr_SetString(PyExc_TypeError,
+                "raise: arg 3 must be a traceback or None");
+            goto raise_error;
+        }
+    }
+    if (PyType_Check(type)) {
+#if CYTHON_COMPILING_IN_PYPY
+        if (!value) {
+            Py_INCREF(Py_None);
+            value = Py_None;
+        }
+#endif
+        PyErr_NormalizeException(&type, &value, &tb);
+    } else {
+        if (value) {
+            PyErr_SetString(PyExc_TypeError,
+                "instance exception may not have a separate value");
+            goto raise_error;
+        }
+        value = type;
+        type = (PyObject*) Py_TYPE(type);
+        Py_INCREF(type);
+        if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
+            PyErr_SetString(PyExc_TypeError,
+                "raise: exception class must be a subclass of BaseException");
+            goto raise_error;
+        }
+    }
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrRestore(type, value, tb);
+    return;
+raise_error:
+    Py_XDECREF(value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+    return;
+}
+#else
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
+    PyObject* owned_instance = NULL;
+    if (tb == Py_None) {
+        tb = 0;
+    } else if (tb && !PyTraceBack_Check(tb)) {
+        PyErr_SetString(PyExc_TypeError,
+            "raise: arg 3 must be a traceback or None");
+        goto bad;
+    }
+    if (value == Py_None)
+        value = 0;
+    if (PyExceptionInstance_Check(type)) {
+        if (value) {
+            PyErr_SetString(PyExc_TypeError,
+                "instance exception may not have a separate value");
+            goto bad;
+        }
+        value = type;
+        type = (PyObject*) Py_TYPE(value);
+    } else if (PyExceptionClass_Check(type)) {
+        PyObject *instance_class = NULL;
+        if (value && PyExceptionInstance_Check(value)) {
+            instance_class = (PyObject*) Py_TYPE(value);
+            if (instance_class != type) {
+                int is_subclass = PyObject_IsSubclass(instance_class, type);
+                if (!is_subclass) {
+                    instance_class = NULL;
+                } else if (unlikely(is_subclass == -1)) {
+                    goto bad;
+                } else {
+                    type = instance_class;
+                }
+            }
+        }
+        if (!instance_class) {
+            PyObject *args;
+            if (!value)
+                args = PyTuple_New(0);
+            else if (PyTuple_Check(value)) {
+                Py_INCREF(value);
+                args = value;
+            } else
+                args = PyTuple_Pack(1, value);
+            if (!args)
+                goto bad;
+            owned_instance = PyObject_Call(type, args, NULL);
+            Py_DECREF(args);
+            if (!owned_instance)
+                goto bad;
+            value = owned_instance;
+            if (!PyExceptionInstance_Check(value)) {
+                PyErr_Format(PyExc_TypeError,
+                             "calling %R should have returned an instance of "
+                             "BaseException, not %R",
+                             type, Py_TYPE(value));
+                goto bad;
+            }
+        }
+    } else {
+        PyErr_SetString(PyExc_TypeError,
+            "raise: exception class must be a subclass of BaseException");
+        goto bad;
+    }
+#if PY_VERSION_HEX >= 0x03030000
+    if (cause) {
+#else
+    if (cause && cause != Py_None) {
+#endif
+        PyObject *fixed_cause;
+        if (cause == Py_None) {
+            fixed_cause = NULL;
+        } else if (PyExceptionClass_Check(cause)) {
+            fixed_cause = PyObject_CallObject(cause, NULL);
+            if (fixed_cause == NULL)
+                goto bad;
+        } else if (PyExceptionInstance_Check(cause)) {
+            fixed_cause = cause;
+            Py_INCREF(fixed_cause);
+        } else {
+            PyErr_SetString(PyExc_TypeError,
+                            "exception causes must derive from "
+                            "BaseException");
+            goto bad;
+        }
+        PyException_SetCause(value, fixed_cause);
+    }
+    PyErr_SetObject(type, value);
+    if (tb) {
+#if CYTHON_COMPILING_IN_PYPY
+        PyObject *tmp_type, *tmp_value, *tmp_tb;
+        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
+        Py_INCREF(tb);
+        PyErr_Restore(tmp_type, tmp_value, tb);
+        Py_XDECREF(tmp_tb);
+#else
+        PyThreadState *tstate = PyThreadState_GET();
+        PyObject* tmp_tb = tstate->curexc_traceback;
+        if (tb != tmp_tb) {
+            Py_INCREF(tb);
+            tstate->curexc_traceback = tb;
+            Py_XDECREF(tmp_tb);
+        }
+#endif
+    }
+bad:
+    Py_XDECREF(owned_instance);
+    return;
+}
+#endif
+
+/* RaiseTooManyValuesToUnpack */
+          static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
+    PyErr_Format(PyExc_ValueError,
+                 "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected);
+}
+
+/* RaiseNeedMoreValuesToUnpack */
+          static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
+    PyErr_Format(PyExc_ValueError,
+                 "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack",
+                 index, (index == 1) ? "" : "s");
+}
+
+/* RaiseNoneIterError */
+          static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+}
+
+/* SaveResetException */
+          #if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+    *type = tstate->exc_type;
+    *value = tstate->exc_value;
+    *tb = tstate->exc_traceback;
+    Py_XINCREF(*type);
+    Py_XINCREF(*value);
+    Py_XINCREF(*tb);
+}
+static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    tstate->exc_type = type;
+    tstate->exc_value = value;
+    tstate->exc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+}
+#endif
+
+/* PyErrExceptionMatches */
+          #if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
+    PyObject *exc_type = tstate->curexc_type;
+    if (exc_type == err) return 1;
+    if (unlikely(!exc_type)) return 0;
+    return PyErr_GivenExceptionMatches(exc_type, err);
+}
+#endif
+
+/* GetException */
+          #if CYTHON_FAST_THREAD_STATE
+static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+#else
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) {
+#endif
+    PyObject *local_type, *local_value, *local_tb;
+#if CYTHON_FAST_THREAD_STATE
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    local_type = tstate->curexc_type;
+    local_value = tstate->curexc_value;
+    local_tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+#else
+    PyErr_Fetch(&local_type, &local_value, &local_tb);
+#endif
+    PyErr_NormalizeException(&local_type, &local_value, &local_tb);
+#if CYTHON_FAST_THREAD_STATE
+    if (unlikely(tstate->curexc_type))
+#else
+    if (unlikely(PyErr_Occurred()))
+#endif
+        goto bad;
+    #if PY_MAJOR_VERSION >= 3
+    if (local_tb) {
+        if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0))
+            goto bad;
+    }
+    #endif
+    Py_XINCREF(local_tb);
+    Py_XINCREF(local_type);
+    Py_XINCREF(local_value);
+    *type = local_type;
+    *value = local_value;
+    *tb = local_tb;
+#if CYTHON_FAST_THREAD_STATE
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    tstate->exc_type = local_type;
+    tstate->exc_value = local_value;
+    tstate->exc_traceback = local_tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#else
+    PyErr_SetExcInfo(local_type, local_value, local_tb);
+#endif
+    return 0;
+bad:
+    *type = 0;
+    *value = 0;
+    *tb = 0;
+    Py_XDECREF(local_type);
+    Py_XDECREF(local_value);
+    Py_XDECREF(local_tb);
+    return -1;
+}
+
+/* Import */
+            static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
+    PyObject *empty_list = 0;
+    PyObject *module = 0;
+    PyObject *global_dict = 0;
+    PyObject *empty_dict = 0;
+    PyObject *list;
+    #if PY_VERSION_HEX < 0x03030000
+    PyObject *py_import;
+    py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import);
+    if (!py_import)
+        goto bad;
+    #endif
+    if (from_list)
+        list = from_list;
+    else {
+        empty_list = PyList_New(0);
+        if (!empty_list)
+            goto bad;
+        list = empty_list;
+    }
+    global_dict = PyModule_GetDict(__pyx_m);
+    if (!global_dict)
+        goto bad;
+    empty_dict = PyDict_New();
+    if (!empty_dict)
+        goto bad;
+    {
+        #if PY_MAJOR_VERSION >= 3
+        if (level == -1) {
+            if (strchr(__Pyx_MODULE_NAME, '.')) {
+                #if PY_VERSION_HEX < 0x03030000
+                PyObject *py_level = PyInt_FromLong(1);
+                if (!py_level)
+                    goto bad;
+                module = PyObject_CallFunctionObjArgs(py_import,
+                    name, global_dict, empty_dict, list, py_level, NULL);
+                Py_DECREF(py_level);
+                #else
+                module = PyImport_ImportModuleLevelObject(
+                    name, global_dict, empty_dict, list, 1);
+                #endif
+                if (!module) {
+                    if (!PyErr_ExceptionMatches(PyExc_ImportError))
+                        goto bad;
+                    PyErr_Clear();
+                }
+            }
+            level = 0;
+        }
+        #endif
+        if (!module) {
+            #if PY_VERSION_HEX < 0x03030000
+            PyObject *py_level = PyInt_FromLong(level);
+            if (!py_level)
+                goto bad;
+            module = PyObject_CallFunctionObjArgs(py_import,
+                name, global_dict, empty_dict, list, py_level, NULL);
+            Py_DECREF(py_level);
+            #else
+            module = PyImport_ImportModuleLevelObject(
+                name, global_dict, empty_dict, list, level);
+            #endif
+        }
+    }
+bad:
+    #if PY_VERSION_HEX < 0x03030000
+    Py_XDECREF(py_import);
+    #endif
+    Py_XDECREF(empty_list);
+    Py_XDECREF(empty_dict);
+    return module;
+}
+
+/* CodeObjectCache */
+            static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
+    int start = 0, mid = 0, end = count - 1;
+    if (end >= 0 && code_line > entries[end].code_line) {
+        return count;
+    }
+    while (start < end) {
+        mid = start + (end - start) / 2;
+        if (code_line < entries[mid].code_line) {
+            end = mid;
+        } else if (code_line > entries[mid].code_line) {
+             start = mid + 1;
+        } else {
+            return mid;
+        }
+    }
+    if (code_line <= entries[mid].code_line) {
+        return mid;
+    } else {
+        return mid + 1;
+    }
+}
+static PyCodeObject *__pyx_find_code_object(int code_line) {
+    PyCodeObject* code_object;
+    int pos;
+    if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) {
+        return NULL;
+    }
+    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
+    if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) {
+        return NULL;
+    }
+    code_object = __pyx_code_cache.entries[pos].code_object;
+    Py_INCREF(code_object);
+    return code_object;
+}
+static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
+    int pos, i;
+    __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries;
+    if (unlikely(!code_line)) {
+        return;
+    }
+    if (unlikely(!entries)) {
+        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry));
+        if (likely(entries)) {
+            __pyx_code_cache.entries = entries;
+            __pyx_code_cache.max_count = 64;
+            __pyx_code_cache.count = 1;
+            entries[0].code_line = code_line;
+            entries[0].code_object = code_object;
+            Py_INCREF(code_object);
+        }
+        return;
+    }
+    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
+    if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) {
+        PyCodeObject* tmp = entries[pos].code_object;
+        entries[pos].code_object = code_object;
+        Py_DECREF(tmp);
+        return;
+    }
+    if (__pyx_code_cache.count == __pyx_code_cache.max_count) {
+        int new_max = __pyx_code_cache.max_count + 64;
+        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc(
+            __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry));
+        if (unlikely(!entries)) {
+            return;
+        }
+        __pyx_code_cache.entries = entries;
+        __pyx_code_cache.max_count = new_max;
+    }
+    for (i=__pyx_code_cache.count; i>pos; i--) {
+        entries[i] = entries[i-1];
+    }
+    entries[pos].code_line = code_line;
+    entries[pos].code_object = code_object;
+    __pyx_code_cache.count++;
+    Py_INCREF(code_object);
+}
+
+/* AddTraceback */
+            #include "compile.h"
+#include "frameobject.h"
+#include "traceback.h"
+static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
+            const char *funcname, int c_line,
+            int py_line, const char *filename) {
+    PyCodeObject *py_code = 0;
+    PyObject *py_srcfile = 0;
+    PyObject *py_funcname = 0;
+    #if PY_MAJOR_VERSION < 3
+    py_srcfile = PyString_FromString(filename);
+    #else
+    py_srcfile = PyUnicode_FromString(filename);
+    #endif
+    if (!py_srcfile) goto bad;
+    if (c_line) {
+        #if PY_MAJOR_VERSION < 3
+        py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
+        #else
+        py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
+        #endif
+    }
+    else {
+        #if PY_MAJOR_VERSION < 3
+        py_funcname = PyString_FromString(funcname);
+        #else
+        py_funcname = PyUnicode_FromString(funcname);
+        #endif
+    }
+    if (!py_funcname) goto bad;
+    py_code = __Pyx_PyCode_New(
+        0,
+        0,
+        0,
+        0,
+        0,
+        __pyx_empty_bytes, /*PyObject *code,*/
+        __pyx_empty_tuple, /*PyObject *consts,*/
+        __pyx_empty_tuple, /*PyObject *names,*/
+        __pyx_empty_tuple, /*PyObject *varnames,*/
+        __pyx_empty_tuple, /*PyObject *freevars,*/
+        __pyx_empty_tuple, /*PyObject *cellvars,*/
+        py_srcfile,   /*PyObject *filename,*/
+        py_funcname,  /*PyObject *name,*/
+        py_line,
+        __pyx_empty_bytes  /*PyObject *lnotab*/
+    );
+    Py_DECREF(py_srcfile);
+    Py_DECREF(py_funcname);
+    return py_code;
+bad:
+    Py_XDECREF(py_srcfile);
+    Py_XDECREF(py_funcname);
+    return NULL;
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyCodeObject *py_code = 0;
+    PyFrameObject *py_frame = 0;
+    py_code = __pyx_find_code_object(c_line ? c_line : py_line);
+    if (!py_code) {
+        py_code = __Pyx_CreateCodeObjectForTraceback(
+            funcname, c_line, py_line, filename);
+        if (!py_code) goto bad;
+        __pyx_insert_code_object(c_line ? c_line : py_line, py_code);
+    }
+    py_frame = PyFrame_New(
+        PyThreadState_GET(), /*PyThreadState *tstate,*/
+        py_code,             /*PyCodeObject *code,*/
+        __pyx_d,      /*PyObject *globals,*/
+        0                    /*PyObject *locals*/
+    );
+    if (!py_frame) goto bad;
+    __Pyx_PyFrame_SetLineNumber(py_frame, py_line);
+    PyTraceBack_Here(py_frame);
+bad:
+    Py_XDECREF(py_code);
+    Py_XDECREF(py_frame);
+}
+
+#if PY_MAJOR_VERSION < 3
+static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) {
+    if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags);
+        if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags);
+    PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name);
+    return -1;
+}
+static void __Pyx_ReleaseBuffer(Py_buffer *view) {
+    PyObject *obj = view->obj;
+    if (!obj) return;
+    if (PyObject_CheckBuffer(obj)) {
+        PyBuffer_Release(view);
+        return;
+    }
+        if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) { __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); return; }
+    Py_DECREF(obj);
+    view->obj = NULL;
+}
+#endif
+
+
+            /* CIntToPy */
+            static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
+    const int neg_one = (int) -1, const_zero = (int) 0;
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(int) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(int) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(int) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(int),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntFromPyVerify */
+            #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
+    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0)
+#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\
+    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1)
+#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\
+    {\
+        func_type value = func_value;\
+        if (sizeof(target_type) < sizeof(func_type)) {\
+            if (unlikely(value != (func_type) (target_type) value)) {\
+                func_type zero = 0;\
+                if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\
+                    return (target_type) -1;\
+                if (is_unsigned && unlikely(value < zero))\
+                    goto raise_neg_overflow;\
+                else\
+                    goto raise_overflow;\
+            }\
+        }\
+        return (target_type) value;\
+    }
+
+/* CIntToPy */
+            static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
+    const long neg_one = (long) -1, const_zero = (long) 0;
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(long) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(long) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(long) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(long),
+                                     little, !is_unsigned);
+    }
+}
+
+/* Declarations */
+            #if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
+      return ::std::complex< float >(x, y);
+    }
+  #else
+    static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
+      return x + y*(__pyx_t_float_complex)_Complex_I;
+    }
+  #endif
+#else
+    static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
+      __pyx_t_float_complex z;
+      z.real = x;
+      z.imag = y;
+      return z;
+    }
+#endif
+
+/* Arithmetic */
+            #if CYTHON_CCOMPLEX
+#else
+    static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+       return (a.real == b.real) && (a.imag == b.imag);
+    }
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        __pyx_t_float_complex z;
+        z.real = a.real + b.real;
+        z.imag = a.imag + b.imag;
+        return z;
+    }
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        __pyx_t_float_complex z;
+        z.real = a.real - b.real;
+        z.imag = a.imag - b.imag;
+        return z;
+    }
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        __pyx_t_float_complex z;
+        z.real = a.real * b.real - a.imag * b.imag;
+        z.imag = a.real * b.imag + a.imag * b.real;
+        return z;
+    }
+    #if 1
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        if (b.imag == 0) {
+            return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real);
+        } else if (fabsf(b.real) >= fabsf(b.imag)) {
+            if (b.real == 0 && b.imag == 0) {
+                return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag);
+            } else {
+                float r = b.imag / b.real;
+                float s = 1.0 / (b.real + b.imag * r);
+                return __pyx_t_float_complex_from_parts(
+                    (a.real + a.imag * r) * s, (a.imag - a.real * r) * s);
+            }
+        } else {
+            float r = b.real / b.imag;
+            float s = 1.0 / (b.imag + b.real * r);
+            return __pyx_t_float_complex_from_parts(
+                (a.real * r + a.imag) * s, (a.imag * r - a.real) * s);
+        }
+    }
+    #else
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        if (b.imag == 0) {
+            return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real);
+        } else {
+            float denom = b.real * b.real + b.imag * b.imag;
+            return __pyx_t_float_complex_from_parts(
+                (a.real * b.real + a.imag * b.imag) / denom,
+                (a.imag * b.real - a.real * b.imag) / denom);
+        }
+    }
+    #endif
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) {
+        __pyx_t_float_complex z;
+        z.real = -a.real;
+        z.imag = -a.imag;
+        return z;
+    }
+    static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) {
+       return (a.real == 0) && (a.imag == 0);
+    }
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) {
+        __pyx_t_float_complex z;
+        z.real =  a.real;
+        z.imag = -a.imag;
+        return z;
+    }
+    #if 1
+        static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) {
+          #if !defined(HAVE_HYPOT) || defined(_MSC_VER)
+            return sqrtf(z.real*z.real + z.imag*z.imag);
+          #else
+            return hypotf(z.real, z.imag);
+          #endif
+        }
+        static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+            __pyx_t_float_complex z;
+            float r, lnr, theta, z_r, z_theta;
+            if (b.imag == 0 && b.real == (int)b.real) {
+                if (b.real < 0) {
+                    float denom = a.real * a.real + a.imag * a.imag;
+                    a.real = a.real / denom;
+                    a.imag = -a.imag / denom;
+                    b.real = -b.real;
+                }
+                switch ((int)b.real) {
+                    case 0:
+                        z.real = 1;
+                        z.imag = 0;
+                        return z;
+                    case 1:
+                        return a;
+                    case 2:
+                        z = __Pyx_c_prod_float(a, a);
+                        return __Pyx_c_prod_float(a, a);
+                    case 3:
+                        z = __Pyx_c_prod_float(a, a);
+                        return __Pyx_c_prod_float(z, a);
+                    case 4:
+                        z = __Pyx_c_prod_float(a, a);
+                        return __Pyx_c_prod_float(z, z);
+                }
+            }
+            if (a.imag == 0) {
+                if (a.real == 0) {
+                    return a;
+                } else if (b.imag == 0) {
+                    z.real = powf(a.real, b.real);
+                    z.imag = 0;
+                    return z;
+                } else if (a.real > 0) {
+                    r = a.real;
+                    theta = 0;
+                } else {
+                    r = -a.real;
+                    theta = atan2f(0, -1);
+                }
+            } else {
+                r = __Pyx_c_abs_float(a);
+                theta = atan2f(a.imag, a.real);
+            }
+            lnr = logf(r);
+            z_r = expf(lnr * b.real - theta * b.imag);
+            z_theta = theta * b.real + lnr * b.imag;
+            z.real = z_r * cosf(z_theta);
+            z.imag = z_r * sinf(z_theta);
+            return z;
+        }
+    #endif
+#endif
+
+/* Declarations */
+            #if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
+      return ::std::complex< double >(x, y);
+    }
+  #else
+    static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
+      return x + y*(__pyx_t_double_complex)_Complex_I;
+    }
+  #endif
+#else
+    static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
+      __pyx_t_double_complex z;
+      z.real = x;
+      z.imag = y;
+      return z;
+    }
+#endif
+
+/* Arithmetic */
+            #if CYTHON_CCOMPLEX
+#else
+    static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+       return (a.real == b.real) && (a.imag == b.imag);
+    }
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        __pyx_t_double_complex z;
+        z.real = a.real + b.real;
+        z.imag = a.imag + b.imag;
+        return z;
+    }
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        __pyx_t_double_complex z;
+        z.real = a.real - b.real;
+        z.imag = a.imag - b.imag;
+        return z;
+    }
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        __pyx_t_double_complex z;
+        z.real = a.real * b.real - a.imag * b.imag;
+        z.imag = a.real * b.imag + a.imag * b.real;
+        return z;
+    }
+    #if 1
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        if (b.imag == 0) {
+            return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real);
+        } else if (fabs(b.real) >= fabs(b.imag)) {
+            if (b.real == 0 && b.imag == 0) {
+                return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag);
+            } else {
+                double r = b.imag / b.real;
+                double s = 1.0 / (b.real + b.imag * r);
+                return __pyx_t_double_complex_from_parts(
+                    (a.real + a.imag * r) * s, (a.imag - a.real * r) * s);
+            }
+        } else {
+            double r = b.real / b.imag;
+            double s = 1.0 / (b.imag + b.real * r);
+            return __pyx_t_double_complex_from_parts(
+                (a.real * r + a.imag) * s, (a.imag * r - a.real) * s);
+        }
+    }
+    #else
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        if (b.imag == 0) {
+            return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real);
+        } else {
+            double denom = b.real * b.real + b.imag * b.imag;
+            return __pyx_t_double_complex_from_parts(
+                (a.real * b.real + a.imag * b.imag) / denom,
+                (a.imag * b.real - a.real * b.imag) / denom);
+        }
+    }
+    #endif
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) {
+        __pyx_t_double_complex z;
+        z.real = -a.real;
+        z.imag = -a.imag;
+        return z;
+    }
+    static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) {
+       return (a.real == 0) && (a.imag == 0);
+    }
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) {
+        __pyx_t_double_complex z;
+        z.real =  a.real;
+        z.imag = -a.imag;
+        return z;
+    }
+    #if 1
+        static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) {
+          #if !defined(HAVE_HYPOT) || defined(_MSC_VER)
+            return sqrt(z.real*z.real + z.imag*z.imag);
+          #else
+            return hypot(z.real, z.imag);
+          #endif
+        }
+        static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+            __pyx_t_double_complex z;
+            double r, lnr, theta, z_r, z_theta;
+            if (b.imag == 0 && b.real == (int)b.real) {
+                if (b.real < 0) {
+                    double denom = a.real * a.real + a.imag * a.imag;
+                    a.real = a.real / denom;
+                    a.imag = -a.imag / denom;
+                    b.real = -b.real;
+                }
+                switch ((int)b.real) {
+                    case 0:
+                        z.real = 1;
+                        z.imag = 0;
+                        return z;
+                    case 1:
+                        return a;
+                    case 2:
+                        z = __Pyx_c_prod_double(a, a);
+                        return __Pyx_c_prod_double(a, a);
+                    case 3:
+                        z = __Pyx_c_prod_double(a, a);
+                        return __Pyx_c_prod_double(z, a);
+                    case 4:
+                        z = __Pyx_c_prod_double(a, a);
+                        return __Pyx_c_prod_double(z, z);
+                }
+            }
+            if (a.imag == 0) {
+                if (a.real == 0) {
+                    return a;
+                } else if (b.imag == 0) {
+                    z.real = pow(a.real, b.real);
+                    z.imag = 0;
+                    return z;
+                } else if (a.real > 0) {
+                    r = a.real;
+                    theta = 0;
+                } else {
+                    r = -a.real;
+                    theta = atan2(0, -1);
+                }
+            } else {
+                r = __Pyx_c_abs_double(a);
+                theta = atan2(a.imag, a.real);
+            }
+            lnr = log(r);
+            z_r = exp(lnr * b.real - theta * b.imag);
+            z_theta = theta * b.real + lnr * b.imag;
+            z.real = z_r * cos(z_theta);
+            z.imag = z_r * sin(z_theta);
+            return z;
+        }
+    #endif
+#endif
+
+/* CIntToPy */
+            static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) {
+    const enum NPY_TYPES neg_one = (enum NPY_TYPES) -1, const_zero = (enum NPY_TYPES) 0;
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(enum NPY_TYPES) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(enum NPY_TYPES) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntFromPy */
+            static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
+    const int neg_one = (int) -1, const_zero = (int) 0;
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(int) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (int) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (int) 0;
+                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
+                case 2:
+                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
+                            return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
+                            return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
+                            return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                        }
+                    }
+                    break;
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (int) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if (sizeof(int) <= sizeof(unsigned long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (int) 0;
+                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
+                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
+                case -2:
+                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                            return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case 2:
+                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                            return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case -3:
+                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                            return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                            return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case -4:
+                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                            return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                            return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+            }
+#endif
+            if (sizeof(int) <= sizeof(long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+            PyErr_SetString(PyExc_RuntimeError,
+                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+            int val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+ #endif
+            if (likely(v)) {
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                int ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                              bytes, sizeof(val),
+                                              is_little, !is_unsigned);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            return (int) -1;
+        }
+    } else {
+        int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (int) -1;
+        val = __Pyx_PyInt_As_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to int");
+    return (int) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to int");
+    return (int) -1;
+}
+
+/* CIntFromPy */
+            static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
+    const long neg_one = (long) -1, const_zero = (long) 0;
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(long) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (long) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (long) 0;
+                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
+                case 2:
+                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
+                            return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
+                            return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
+                            return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                        }
+                    }
+                    break;
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (long) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if (sizeof(long) <= sizeof(unsigned long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (long) 0;
+                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
+                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
+                case -2:
+                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                            return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case 2:
+                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                            return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case -3:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                            return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                            return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case -4:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                            return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                            return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+            }
+#endif
+            if (sizeof(long) <= sizeof(long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+            PyErr_SetString(PyExc_RuntimeError,
+                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+            long val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+ #endif
+            if (likely(v)) {
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                int ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                              bytes, sizeof(val),
+                                              is_little, !is_unsigned);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            return (long) -1;
+        }
+    } else {
+        long val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (long) -1;
+        val = __Pyx_PyInt_As_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to long");
+    return (long) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to long");
+    return (long) -1;
+}
+
+/* CheckBinaryVersion */
+            static int __Pyx_check_binary_version(void) {
+    char ctversion[4], rtversion[4];
+    PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
+    PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion());
+    if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) {
+        char message[200];
+        PyOS_snprintf(message, sizeof(message),
+                      "compiletime version %s of module '%.100s' "
+                      "does not match runtime version %s",
+                      ctversion, __Pyx_MODULE_NAME, rtversion);
+        return PyErr_WarnEx(NULL, message, 1);
+    }
+    return 0;
+}
+
+/* ModuleImport */
+            #ifndef __PYX_HAVE_RT_ImportModule
+#define __PYX_HAVE_RT_ImportModule
+static PyObject *__Pyx_ImportModule(const char *name) {
+    PyObject *py_name = 0;
+    PyObject *py_module = 0;
+    py_name = __Pyx_PyIdentifier_FromString(name);
+    if (!py_name)
+        goto bad;
+    py_module = PyImport_Import(py_name);
+    Py_DECREF(py_name);
+    return py_module;
+bad:
+    Py_XDECREF(py_name);
+    return 0;
+}
+#endif
+
+/* TypeImport */
+            #ifndef __PYX_HAVE_RT_ImportType
+#define __PYX_HAVE_RT_ImportType
+static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name,
+    size_t size, int strict)
+{
+    PyObject *py_module = 0;
+    PyObject *result = 0;
+    PyObject *py_name = 0;
+    char warning[200];
+    Py_ssize_t basicsize;
+#ifdef Py_LIMITED_API
+    PyObject *py_basicsize;
+#endif
+    py_module = __Pyx_ImportModule(module_name);
+    if (!py_module)
+        goto bad;
+    py_name = __Pyx_PyIdentifier_FromString(class_name);
+    if (!py_name)
+        goto bad;
+    result = PyObject_GetAttr(py_module, py_name);
+    Py_DECREF(py_name);
+    py_name = 0;
+    Py_DECREF(py_module);
+    py_module = 0;
+    if (!result)
+        goto bad;
+    if (!PyType_Check(result)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s.%.200s is not a type object",
+            module_name, class_name);
+        goto bad;
+    }
+#ifndef Py_LIMITED_API
+    basicsize = ((PyTypeObject *)result)->tp_basicsize;
+#else
+    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
+    if (!py_basicsize)
+        goto bad;
+    basicsize = PyLong_AsSsize_t(py_basicsize);
+    Py_DECREF(py_basicsize);
+    py_basicsize = 0;
+    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
+#endif
+    if (!strict && (size_t)basicsize > size) {
+        PyOS_snprintf(warning, sizeof(warning),
+            "%s.%s size changed, may indicate binary incompatibility. Expected %zd, got %zd",
+            module_name, class_name, basicsize, size);
+        if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
+    }
+    else if ((size_t)basicsize != size) {
+        PyErr_Format(PyExc_ValueError,
+            "%.200s.%.200s has the wrong size, try recompiling. Expected %zd, got %zd",
+            module_name, class_name, basicsize, size);
+        goto bad;
+    }
+    return (PyTypeObject *)result;
+bad:
+    Py_XDECREF(py_module);
+    Py_XDECREF(result);
+    return NULL;
+}
+#endif
+
+/* InitStrings */
+            static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
+    while (t->p) {
+        #if PY_MAJOR_VERSION < 3
+        if (t->is_unicode) {
+            *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
+        } else if (t->intern) {
+            *t->p = PyString_InternFromString(t->s);
+        } else {
+            *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
+        }
+        #else
+        if (t->is_unicode | t->is_str) {
+            if (t->intern) {
+                *t->p = PyUnicode_InternFromString(t->s);
+            } else if (t->encoding) {
+                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
+            } else {
+                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
+            }
+        } else {
+            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
+        }
+        #endif
+        if (!*t->p)
+            return -1;
+        ++t;
+    }
+    return 0;
+}
+
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
+}
+static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) {
+    Py_ssize_t ignore;
+    return __Pyx_PyObject_AsStringAndSize(o, &ignore);
+}
+static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
+    if (
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+            __Pyx_sys_getdefaultencoding_not_ascii &&
+#endif
+            PyUnicode_Check(o)) {
+#if PY_VERSION_HEX < 0x03030000
+        char* defenc_c;
+        PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL);
+        if (!defenc) return NULL;
+        defenc_c = PyBytes_AS_STRING(defenc);
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+        {
+            char* end = defenc_c + PyBytes_GET_SIZE(defenc);
+            char* c;
+            for (c = defenc_c; c < end; c++) {
+                if ((unsigned char) (*c) >= 128) {
+                    PyUnicode_AsASCIIString(o);
+                    return NULL;
+                }
+            }
+        }
+#endif
+        *length = PyBytes_GET_SIZE(defenc);
+        return defenc_c;
+#else
+        if (__Pyx_PyUnicode_READY(o) == -1) return NULL;
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+        if (PyUnicode_IS_ASCII(o)) {
+            *length = PyUnicode_GET_LENGTH(o);
+            return PyUnicode_AsUTF8(o);
+        } else {
+            PyUnicode_AsASCIIString(o);
+            return NULL;
+        }
+#else
+        return PyUnicode_AsUTF8AndSize(o, length);
+#endif
+#endif
+    } else
+#endif
+#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+    if (PyByteArray_Check(o)) {
+        *length = PyByteArray_GET_SIZE(o);
+        return PyByteArray_AS_STRING(o);
+    } else
+#endif
+    {
+        char* result;
+        int r = PyBytes_AsStringAndSize(o, &result, length);
+        if (unlikely(r < 0)) {
+            return NULL;
+        } else {
+            return result;
+        }
+    }
+}
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
+   int is_true = x == Py_True;
+   if (is_true | (x == Py_False) | (x == Py_None)) return is_true;
+   else return PyObject_IsTrue(x);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) {
+#if CYTHON_USE_TYPE_SLOTS
+  PyNumberMethods *m;
+#endif
+  const char *name = NULL;
+  PyObject *res = NULL;
+#if PY_MAJOR_VERSION < 3
+  if (PyInt_Check(x) || PyLong_Check(x))
+#else
+  if (PyLong_Check(x))
+#endif
+    return __Pyx_NewRef(x);
+#if CYTHON_USE_TYPE_SLOTS
+  m = Py_TYPE(x)->tp_as_number;
+  #if PY_MAJOR_VERSION < 3
+  if (m && m->nb_int) {
+    name = "int";
+    res = PyNumber_Int(x);
+  }
+  else if (m && m->nb_long) {
+    name = "long";
+    res = PyNumber_Long(x);
+  }
+  #else
+  if (m && m->nb_int) {
+    name = "int";
+    res = PyNumber_Long(x);
+  }
+  #endif
+#else
+  res = PyNumber_Int(x);
+#endif
+  if (res) {
+#if PY_MAJOR_VERSION < 3
+    if (!PyInt_Check(res) && !PyLong_Check(res)) {
+#else
+    if (!PyLong_Check(res)) {
+#endif
+      PyErr_Format(PyExc_TypeError,
+                   "__%.4s__ returned non-%.4s (type %.200s)",
+                   name, name, Py_TYPE(res)->tp_name);
+      Py_DECREF(res);
+      return NULL;
+    }
+  }
+  else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_TypeError,
+                    "an integer is required");
+  }
+  return res;
+}
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
+  Py_ssize_t ival;
+  PyObject *x;
+#if PY_MAJOR_VERSION < 3
+  if (likely(PyInt_CheckExact(b))) {
+    if (sizeof(Py_ssize_t) >= sizeof(long))
+        return PyInt_AS_LONG(b);
+    else
+        return PyInt_AsSsize_t(x);
+  }
+#endif
+  if (likely(PyLong_CheckExact(b))) {
+    #if CYTHON_USE_PYLONG_INTERNALS
+    const digit* digits = ((PyLongObject*)b)->ob_digit;
+    const Py_ssize_t size = Py_SIZE(b);
+    if (likely(__Pyx_sst_abs(size) <= 1)) {
+        ival = likely(size) ? digits[0] : 0;
+        if (size == -1) ival = -ival;
+        return ival;
+    } else {
+      switch (size) {
+         case 2:
+           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -2:
+           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case 3:
+           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -3:
+           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case 4:
+           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -4:
+           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+      }
+    }
+    #endif
+    return PyLong_AsSsize_t(b);
+  }
+  x = PyNumber_Index(b);
+  if (!x) return -1;
+  ival = PyInt_AsSsize_t(x);
+  Py_DECREF(x);
+  return ival;
+}
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
+    return PyInt_FromSize_t(ival);
+}
+
+
+#endif /* Py_PYTHON_H */
diff --git a/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/nms.pyx b/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/nms.pyx
new file mode 100755
index 0000000..344f66d
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/nms.pyx
@@ -0,0 +1,123 @@
+# --------------------------------------------------------
+# Fast R-CNN
+# Copyright (c) 2015 Microsoft
+# Licensed under The MIT License [see LICENSE for details]
+# Written by Ross Girshick
+# --------------------------------------------------------
+
+import numpy as np
+cimport numpy as np
+
+cdef inline np.float32_t max(np.float32_t a, np.float32_t b):
+    return a if a >= b else b
+
+cdef inline np.float32_t min(np.float32_t a, np.float32_t b):
+    return a if a <= b else b
+
+def nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):
+    cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]
+    cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+    cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]
+    cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3]
+    cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4]
+
+    cdef np.ndarray[np.float32_t, ndim=1] areas = (x2 - x1 + 1) * (y2 - y1 + 1)
+    cdef np.ndarray[np.int_t, ndim=1] order = scores.argsort()[::-1]
+
+    cdef int ndets = dets.shape[0]
+    cdef np.ndarray[np.int_t, ndim=1] suppressed = \
+            np.zeros((ndets), dtype=np.int)
+
+    # nominal indices
+    cdef int _i, _j
+    # sorted indices
+    cdef int i, j
+    # temp variables for box i's (the box currently under consideration)
+    cdef np.float32_t ix1, iy1, ix2, iy2, iarea
+    # variables for computing overlap with box j (lower scoring box)
+    cdef np.float32_t xx1, yy1, xx2, yy2
+    cdef np.float32_t w, h
+    cdef np.float32_t inter, ovr
+
+    keep = []
+    for _i in range(ndets):
+        i = order[_i]
+        if suppressed[i] == 1:
+            continue
+        keep.append(i)
+        ix1 = x1[i]
+        iy1 = y1[i]
+        ix2 = x2[i]
+        iy2 = y2[i]
+        iarea = areas[i]
+        for _j in range(_i + 1, ndets):
+            j = order[_j]
+            if suppressed[j] == 1:
+                continue
+            xx1 = max(ix1, x1[j])
+            yy1 = max(iy1, y1[j])
+            xx2 = min(ix2, x2[j])
+            yy2 = min(iy2, y2[j])
+            w = max(0.0, xx2 - xx1 + 1)
+            h = max(0.0, yy2 - yy1 + 1)
+            inter = w * h
+            ovr = inter / (iarea + areas[j] - inter)
+            if ovr >= thresh:
+                suppressed[j] = 1
+
+    return keep
+
+def nms_new(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):
+    cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]
+    cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+    cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]
+    cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3]
+    cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4]
+
+    cdef np.ndarray[np.float32_t, ndim=1] areas = (x2 - x1 + 1) * (y2 - y1 + 1)
+    cdef np.ndarray[np.int_t, ndim=1] order = scores.argsort()[::-1]
+
+    cdef int ndets = dets.shape[0]
+    cdef np.ndarray[np.int_t, ndim=1] suppressed = \
+            np.zeros((ndets), dtype=np.int)
+
+    # nominal indices
+    cdef int _i, _j
+    # sorted indices
+    cdef int i, j
+    # temp variables for box i's (the box currently under consideration)
+    cdef np.float32_t ix1, iy1, ix2, iy2, iarea
+    # variables for computing overlap with box j (lower scoring box)
+    cdef np.float32_t xx1, yy1, xx2, yy2
+    cdef np.float32_t w, h
+    cdef np.float32_t inter, ovr
+
+    keep = []
+    for _i in range(ndets):
+        i = order[_i]
+        if suppressed[i] == 1:
+            continue
+        keep.append(i)
+        ix1 = x1[i]
+        iy1 = y1[i]
+        ix2 = x2[i]
+        iy2 = y2[i]
+        iarea = areas[i]
+        for _j in range(_i + 1, ndets):
+            j = order[_j]
+            if suppressed[j] == 1:
+                continue
+            xx1 = max(ix1, x1[j])
+            yy1 = max(iy1, y1[j])
+            xx2 = min(ix2, x2[j])
+            yy2 = min(iy2, y2[j])
+            w = max(0.0, xx2 - xx1 + 1)
+            h = max(0.0, yy2 - yy1 + 1)
+            inter = w * h
+            ovr = inter / (iarea + areas[j] - inter)
+            ovr1 = inter / iarea
+            ovr2 = inter / areas[j]
+            if ovr >= thresh or ovr1 > 0.95 or ovr2 > 0.95:
+                suppressed[j] = 1
+
+    return keep
diff --git a/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/setup.py b/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/setup.py
new file mode 100755
index 0000000..1227d34
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/box_utils/cython_utils/setup.py
@@ -0,0 +1,133 @@
+# --------------------------------------------------------
+# Fast R-CNN
+# Copyright (c) 2015 Microsoft
+# Licensed under The MIT License [see LICENSE for details]
+# Written by Ross Girshick
+# --------------------------------------------------------
+
+import os
+from os.path import join as pjoin
+import numpy as np
+from distutils.core import setup
+from distutils.extension import Extension
+from Cython.Distutils import build_ext
+
+def find_in_path(name, path):
+    "Find a file in a search path"
+    #adapted fom http://code.activestate.com/recipes/52224-find-a-file-given-a-search-path/
+    for dir in path.split(os.pathsep):
+        binpath = pjoin(dir, name)
+        if os.path.exists(binpath):
+            return os.path.abspath(binpath)
+    return None
+
+def locate_cuda():
+    """Locate the CUDA environment on the system
+
+    Returns a dict with keys 'home', 'nvcc', 'include', and 'lib64'
+    and values giving the absolute path to each directory.
+
+    Starts by looking for the CUDAHOME env variable. If not found, everything
+    is based on finding 'nvcc' in the PATH.
+    """
+
+    # first check if the CUDAHOME env variable is in use
+    if 'CUDAHOME' in os.environ:
+        home = os.environ['CUDAHOME']
+        nvcc = pjoin(home, 'bin', 'nvcc')
+    else:
+        # otherwise, search the PATH for NVCC
+        default_path = pjoin(os.sep, 'usr', 'local', 'cuda', 'bin')
+        nvcc = find_in_path('nvcc', os.environ['PATH'] + os.pathsep + default_path)
+        if nvcc is None:
+            raise EnvironmentError('The nvcc binary could not be '
+                'located in your $PATH. Either add it to your path, or set $CUDAHOME')
+        home = os.path.dirname(os.path.dirname(nvcc))
+
+    cudaconfig = {'home':home, 'nvcc':nvcc,
+                  'include': pjoin(home, 'include'),
+                  'lib64': pjoin(home, 'lib64')}
+    for k, v in cudaconfig.items():
+        if not os.path.exists(v):
+            raise EnvironmentError('The CUDA %s path could not be located in %s' % (k, v))
+
+    return cudaconfig
+CUDA = locate_cuda()
+
+# Obtain the numpy include directory.  This logic works across numpy versions.
+try:
+    numpy_include = np.get_include()
+except AttributeError:
+    numpy_include = np.get_numpy_include()
+
+def customize_compiler_for_nvcc(self):
+    """inject deep into distutils to customize how the dispatch
+    to gcc/nvcc works.
+
+    If you subclass UnixCCompiler, it's not trivial to get your subclass
+    injected in, and still have the right customizations (i.e.
+    distutils.sysconfig.customize_compiler) run on it. So instead of going
+    the OO route, I have this. Note, it's kindof like a wierd functional
+    subclassing going on."""
+
+    # tell the compiler it can processes .cu
+    self.src_extensions.append('.cu')
+
+    # save references to the default compiler_so and _comple methods
+    default_compiler_so = self.compiler_so
+    super = self._compile
+
+    # now redefine the _compile method. This gets executed for each
+    # object but distutils doesn't have the ability to change compilers
+    # based on source extension: we add it.
+    def _compile(obj, src, ext, cc_args, extra_postargs, pp_opts):
+        print(extra_postargs)
+        if os.path.splitext(src)[1] == '.cu':
+            # use the cuda for .cu files
+            self.set_executable('compiler_so', CUDA['nvcc'])
+            # use only a subset of the extra_postargs, which are 1-1 translated
+            # from the extra_compile_args in the Extension class
+            postargs = extra_postargs['nvcc']
+        else:
+            postargs = extra_postargs['gcc']
+
+        super(obj, src, ext, cc_args, postargs, pp_opts)
+        # reset the default compiler_so, which we might have changed for cuda
+        self.compiler_so = default_compiler_so
+
+    # inject our redefined _compile method into the class
+    self._compile = _compile
+
+# run the customize_compiler
+class custom_build_ext(build_ext):
+    def build_extensions(self):
+        customize_compiler_for_nvcc(self.compiler)
+        build_ext.build_extensions(self)
+
+ext_modules = [
+    Extension(
+        "cython_bbox",
+        ["bbox.pyx"],
+        extra_compile_args={'gcc': ["-Wno-cpp", "-Wno-unused-function"]},
+        include_dirs = [numpy_include]
+    ),
+    Extension(
+        "cython_nms",
+        ["nms.pyx"],
+        extra_compile_args={'gcc': ["-Wno-cpp", "-Wno-unused-function"]},
+        include_dirs = [numpy_include]
+    )
+    # Extension(
+    #     "cpu_nms",
+    #     ["cpu_nms.pyx"],
+    #     extra_compile_args={'gcc': ["-Wno-cpp", "-Wno-unused-function"]},
+    #     include_dirs = [numpy_include]
+    # )
+]
+
+setup(
+    name='tf_faster_rcnn',
+    ext_modules=ext_modules,
+    # inject our custom trigger
+    cmdclass={'build_ext': custom_build_ext},
+)
diff --git a/example-apps/PDD/pcb-defect-detection/libs/box_utils/draw_box_in_img.py b/example-apps/PDD/pcb-defect-detection/libs/box_utils/draw_box_in_img.py
new file mode 100755
index 0000000..c80c5d2
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/box_utils/draw_box_in_img.py
@@ -0,0 +1,160 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import, print_function, division
+
+import numpy as np
+
+from PIL import Image, ImageDraw, ImageFont
+import cv2
+
+from libs.configs import cfgs
+from libs.label_name_dict.label_dict import LABEl_NAME_MAP
+NOT_DRAW_BOXES = 0
+ONLY_DRAW_BOXES = -1
+ONLY_DRAW_BOXES_WITH_SCORES = -2
+
+STANDARD_COLORS = [
+    'AliceBlue', 'Chartreuse', 'Aqua', 'Aquamarine', 'Azure', 'Beige', 'Bisque',
+    'BlanchedAlmond', 'BlueViolet', 'BurlyWood', 'CadetBlue', 'AntiqueWhite',
+    'Chocolate', 'Coral', 'CornflowerBlue', 'Cornsilk', 'Crimson', 'Cyan',
+    'DarkCyan', 'DarkGoldenRod', 'DarkGrey', 'DarkKhaki', 'DarkOrange',
+    'DarkOrchid', 'DarkSalmon', 'DarkSeaGreen', 'DarkTurquoise', 'DarkViolet',
+    'DeepPink', 'DeepSkyBlue', 'DodgerBlue', 'FireBrick', 'FloralWhite',
+    'ForestGreen', 'Fuchsia', 'Gainsboro', 'GhostWhite', 'Gold', 'GoldenRod',
+    'Salmon', 'Tan', 'HoneyDew', 'HotPink', 'IndianRed', 'Ivory', 'Khaki',
+    'Lavender', 'LavenderBlush', 'LawnGreen', 'LemonChiffon', 'LightBlue',
+    'LightCoral', 'LightCyan', 'LightGoldenRodYellow', 'LightGray', 'LightGrey',
+    'LightGreen', 'LightPink', 'LightSalmon', 'LightSeaGreen', 'LightSkyBlue',
+    'LightSlateGray', 'LightSlateGrey', 'LightSteelBlue', 'LightYellow', 'Lime',
+    'LimeGreen', 'Linen', 'Magenta', 'MediumAquaMarine', 'MediumOrchid',
+    'MediumPurple', 'MediumSeaGreen', 'MediumSlateBlue', 'MediumSpringGreen',
+    'MediumTurquoise', 'MediumVioletRed', 'MintCream', 'MistyRose', 'Moccasin',
+    'NavajoWhite', 'OldLace', 'Olive', 'OliveDrab', 'Orange', 'OrangeRed',
+    'Orchid', 'PaleGoldenRod', 'PaleGreen', 'PaleTurquoise', 'PaleVioletRed',
+    'PapayaWhip', 'PeachPuff', 'Peru', 'Pink', 'Plum', 'PowderBlue', 'Purple',
+    'Red', 'RosyBrown', 'RoyalBlue', 'SaddleBrown', 'Green', 'SandyBrown',
+    'SeaGreen', 'SeaShell', 'Sienna', 'Silver', 'SkyBlue', 'SlateBlue',
+    'SlateGray', 'SlateGrey', 'Snow', 'SpringGreen', 'SteelBlue', 'GreenYellow',
+    'Teal', 'Thistle', 'Tomato', 'Turquoise', 'Violet', 'Wheat', 'White',
+    'WhiteSmoke', 'Yellow', 'YellowGreen', 'LightBlue', 'LightGreen'
+]
+FONT = ImageFont.load_default()
+
+
+def draw_a_rectangel_in_img(draw_obj, box, color, width):
+    '''
+    use draw lines to draw rectangle. since the draw_rectangle func can not modify the width of rectangle
+    :param draw_obj:
+    :param box: [x1, y1, x2, y2]
+    :return:
+    '''
+    x1, y1, x2, y2 = box[0], box[1], box[2], box[3]
+    top_left, top_right = (x1, y1), (x2, y1)
+    bottom_left, bottom_right = (x1, y2), (x2, y2)
+
+    draw_obj.line(xy=[top_left, top_right],
+                  fill=color,
+                  width=width)
+    draw_obj.line(xy=[top_left, bottom_left],
+                  fill=color,
+                  width=width)
+    draw_obj.line(xy=[bottom_left, bottom_right],
+                  fill=color,
+                  width=width)
+    draw_obj.line(xy=[top_right, bottom_right],
+                  fill=color,
+                  width=width)
+
+
+def only_draw_scores(draw_obj, box, score, color):
+
+    x, y = box[0], box[1]
+    draw_obj.rectangle(xy=[x, y-10, x+100, y],
+                       fill=color)
+    draw_obj.text(xy=(x, y-10),
+                  text="obj:" +str(round(score, 2)),
+                  fill='white',
+                  font=FONT)
+
+
+def draw_label_with_scores(draw_obj, box, label, score, color):
+    x, y = box[0], box[1]
+    draw_obj.rectangle(xy=[x, y-10, x+100, y],
+                       fill=color)
+
+    txt = LABEl_NAME_MAP[label] + ':' + str(round(score, 2))
+    draw_obj.text(xy=(x, y-10),
+                  text=txt,
+                  fill='white',
+                  font=FONT)
+
+
+def draw_boxes_with_label_and_scores(img_array, boxes, labels, scores):
+
+    img_array = img_array + np.array(cfgs.PIXEL_MEAN)
+    img_array.astype(np.float32)
+    boxes = boxes.astype(np.int64)
+    labels = labels.astype(np.int32)
+    img_array = np.array(img_array * 255 / np.max(img_array), dtype=np.uint8)
+
+    img_obj = Image.fromarray(img_array)
+    raw_img_obj = img_obj.copy()
+
+    draw_obj = ImageDraw.Draw(img_obj)
+    num_of_objs = 0
+    for box, a_label, a_score in zip(boxes, labels, scores):
+
+        if a_label != NOT_DRAW_BOXES:
+            num_of_objs += 1
+            #draw_a_rectangel_in_img(draw_obj, box, color=STANDARD_COLORS[a_label], width=3)
+            draw_a_rectangel_in_img(draw_obj, box, color='Red', width=3)
+            if a_label == ONLY_DRAW_BOXES:  # -1
+                continue
+            elif a_label == ONLY_DRAW_BOXES_WITH_SCORES:  # -2
+                 only_draw_scores(draw_obj, box, a_score, color='Yellow')
+                 continue
+            else:
+                draw_label_with_scores(draw_obj, box, a_label, a_score, color='DeepSkyBlue')
+
+    out_img_obj = Image.blend(raw_img_obj, img_obj, alpha=0.7)
+
+    return np.array(out_img_obj)
+
+
+if __name__ == '__main__':
+    img_array = cv2.imread("/home/yjr/PycharmProjects/FPN_TF/tools/inference_image/2.jpg")
+    img_array = np.array(img_array, np.float32) - np.array(cfgs.PIXEL_MEAN)
+    boxes = np.array(
+        [[200, 200, 500, 500],
+         [300, 300, 400, 400],
+         [200, 200, 400, 400]]
+    )
+
+    # test only draw boxes
+    labes = np.ones(shape=[len(boxes), ], dtype=np.float32) * ONLY_DRAW_BOXES
+    scores = np.zeros_like(labes)
+    imm = draw_boxes_with_label_and_scores(img_array, boxes, labes ,scores)
+    # imm = np.array(imm)
+
+    cv2.imshow("te", imm)
+
+    # test only draw scores
+    labes = np.ones(shape=[len(boxes), ], dtype=np.float32) * ONLY_DRAW_BOXES_WITH_SCORES
+    scores = np.random.rand((len(boxes))) * 10
+    imm2 = draw_boxes_with_label_and_scores(img_array, boxes, labes, scores)
+
+    cv2.imshow("te2", imm2)
+    # test draw label and scores
+
+    labels = np.arange(1, 4)
+    imm3 = draw_boxes_with_label_and_scores(img_array, boxes, labels, scores)
+    cv2.imshow("te3", imm3)
+
+    cv2.waitKey(0)
+
+
+
+
+
+
+
diff --git a/example-apps/PDD/pcb-defect-detection/libs/box_utils/encode_and_decode.py b/example-apps/PDD/pcb-defect-detection/libs/box_utils/encode_and_decode.py
new file mode 100755
index 0000000..66092b2
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/box_utils/encode_and_decode.py
@@ -0,0 +1,165 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import
+from __future__ import print_function
+from __future__ import division
+
+import tensorflow as tf
+import numpy as np
+
+
+
+# def encode_boxes(ex_rois, gt_rois, scale_factor=None):
+#     ex_widths = ex_rois[:, 2] - ex_rois[:, 0] + 1.0
+#     ex_heights = ex_rois[:, 3] - ex_rois[:, 1] + 1.0
+#     ex_ctr_x = ex_rois[:, 0] + 0.5 * ex_widths
+#     ex_ctr_y = ex_rois[:, 1] + 0.5 * ex_heights
+#
+#     gt_widths = gt_rois[:, 2] - gt_rois[:, 0] + 1.0
+#     gt_heights = gt_rois[:, 3] - gt_rois[:, 1] + 1.0
+#     gt_ctr_x = gt_rois[:, 0] + 0.5 * gt_widths
+#     gt_ctr_y = gt_rois[:, 1] + 0.5 * gt_heights
+#
+#     targets_dx = (gt_ctr_x - ex_ctr_x) / ex_widths
+#     targets_dy = (gt_ctr_y - ex_ctr_y) / ex_heights
+#     targets_dw = np.log(gt_widths / ex_widths)
+#     targets_dh = np.log(gt_heights / ex_heights)
+#
+#     if scale_factor:
+#         targets_dx = targets_dx * scale_factor[0]
+#         targets_dy = targets_dy * scale_factor[1]
+#         targets_dw = targets_dw * scale_factor[2]
+#         targets_dh = targets_dh * scale_factor[3]
+#
+#     targets = np.vstack(
+#         (targets_dx, targets_dy, targets_dw, targets_dh)).transpose()
+#     return targets
+#
+#
+# def _concat_new_axis(t1, t2, t3, t4, axis):
+#     return tf.concat(
+#         [tf.expand_dims(t1, -1), tf.expand_dims(t2, -1),
+#          tf.expand_dims(t3, -1), tf.expand_dims(t4, -1)], axis=axis)
+#
+#
+# def decode_boxes(boxes, deltas, scale_factor=None):
+#     widths = boxes[:, 2] - boxes[:, 0] + 1.0
+#     heights = boxes[:, 3] - boxes[:, 1] + 1.0
+#     ctr_x = tf.expand_dims(boxes[:, 0] + 0.5 * widths, -1)
+#     ctr_y = tf.expand_dims(boxes[:, 1] + 0.5 * heights, -1)
+#
+#     dx = deltas[:, 0::4]
+#     dy = deltas[:, 1::4]
+#     dw = deltas[:, 2::4]
+#     dh = deltas[:, 3::4]
+#
+#     if scale_factor:
+#         dx /= scale_factor[0]
+#         dy /= scale_factor[1]
+#         dw /= scale_factor[2]
+#         dh /= scale_factor[3]
+#
+#     widths = tf.expand_dims(widths, -1)
+#     heights = tf.expand_dims(heights, -1)
+#
+#     pred_ctr_x = dx * widths + ctr_x
+#     pred_ctr_y = dy * heights + ctr_y
+#     pred_w = tf.exp(dw) * widths
+#     pred_h = tf.exp(dh) * heights
+#
+#     # x1
+#     # pred_boxes[:, 0::4] = pred_ctr_x - 0.5 * pred_w
+#     pred_x1 = pred_ctr_x - 0.5 * pred_w
+#     # y1
+#     # pred_boxes[:, 1::4] = pred_ctr_y - 0.5 * pred_h
+#     pred_y1 = pred_ctr_y - 0.5 * pred_h
+#     # x2
+#     # pred_boxes[:, 2::4] = pred_ctr_x + 0.5 * pred_w
+#     pred_x2 = pred_ctr_x + 0.5 * pred_w
+#     # y2
+#     # pred_boxes[:, 3::4] = pred_ctr_y + 0.5 * pred_h
+#     pred_y2 = pred_ctr_y + 0.5 * pred_h
+#
+#     pred_boxes = _concat_new_axis(pred_x1, pred_y1, pred_x2, pred_y2, 2)
+#     pred_boxes = tf.reshape(pred_boxes, (tf.shape(pred_boxes)[0], -1))
+#     return pred_boxes
+
+
+def decode_boxes(encoded_boxes, reference_boxes, scale_factors=None):
+    '''
+
+    :param encoded_boxes:[N, 4]
+    :param reference_boxes: [N, 4] .
+    :param scale_factors: use for scale.
+
+    in the first stage, reference_boxes  are anchors
+    in the second stage, reference boxes are proposals(decode) produced by first stage
+    :return:decode boxes [N, 4]
+    '''
+
+    t_xcenter, t_ycenter, t_w, t_h = tf.unstack(encoded_boxes, axis=1)
+    if scale_factors:
+        t_xcenter /= scale_factors[0]
+        t_ycenter /= scale_factors[1]
+        t_w /= scale_factors[2]
+        t_h /= scale_factors[3]
+
+    reference_xmin, reference_ymin, reference_xmax, reference_ymax = tf.unstack(reference_boxes, axis=1)
+    # reference boxes are anchors in the first stage
+
+    reference_xcenter = (reference_xmin + reference_xmax) / 2.
+    reference_ycenter = (reference_ymin + reference_ymax) / 2.
+    reference_w = reference_xmax - reference_xmin
+    reference_h = reference_ymax - reference_ymin
+
+    predict_xcenter = t_xcenter * reference_w + reference_xcenter
+    predict_ycenter = t_ycenter * reference_h + reference_ycenter
+    predict_w = tf.exp(t_w) * reference_w
+    predict_h = tf.exp(t_h) * reference_h
+
+    predict_xmin = predict_xcenter - predict_w / 2.
+    predict_xmax = predict_xcenter + predict_w / 2.
+    predict_ymin = predict_ycenter - predict_h / 2.
+    predict_ymax = predict_ycenter + predict_h / 2.
+
+    return tf.transpose(tf.stack([predict_xmin, predict_ymin,
+                                  predict_xmax, predict_ymax]))
+
+
+def encode_boxes(unencode_boxes, reference_boxes, scale_factors=None):
+    '''
+
+    :param unencode_boxes: [-1, 4]
+    :param reference_boxes: [-1, 4]
+    :return: encode_boxes [-1, 4]
+    '''
+
+    xmin, ymin, xmax, ymax = unencode_boxes[:, 0], unencode_boxes[:, 1], unencode_boxes[:, 2], unencode_boxes[:, 3]
+
+    reference_xmin, reference_ymin, reference_xmax, reference_ymax = reference_boxes[:, 0], reference_boxes[:, 1], \
+                                                                     reference_boxes[:, 2], reference_boxes[:, 3]
+
+    x_center = (xmin + xmax) / 2.
+    y_center = (ymin + ymax) / 2.
+    w = xmax - xmin + 1e-8
+    h = ymax - ymin + 1e-8
+
+    reference_xcenter = (reference_xmin + reference_xmax) / 2.
+    reference_ycenter = (reference_ymin + reference_ymax) / 2.
+    reference_w = reference_xmax - reference_xmin + 1e-8
+    reference_h = reference_ymax - reference_ymin + 1e-8
+
+    # w + 1e-8 to avoid NaN in division and log below
+
+    t_xcenter = (x_center - reference_xcenter) / reference_w
+    t_ycenter = (y_center - reference_ycenter) / reference_h
+    t_w = np.log(w/reference_w)
+    t_h = np.log(h/reference_h)
+
+    if scale_factors:
+        t_xcenter *= scale_factors[0]
+        t_ycenter *= scale_factors[1]
+        t_w *= scale_factors[2]
+        t_h *= scale_factors[3]
+
+    return np.transpose(np.stack([t_xcenter, t_ycenter, t_w, t_h], axis=0))
diff --git a/example-apps/PDD/pcb-defect-detection/libs/box_utils/show_box_in_tensor.py b/example-apps/PDD/pcb-defect-detection/libs/box_utils/show_box_in_tensor.py
new file mode 100755
index 0000000..37afda0
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/box_utils/show_box_in_tensor.py
@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf
+import numpy as np
+import cv2
+from libs.label_name_dict.label_dict import LABEl_NAME_MAP
+
+from libs.configs import cfgs
+
+from libs.box_utils import draw_box_in_img
+
+def only_draw_boxes(img_batch, boxes):
+
+    boxes = tf.stop_gradient(boxes)
+    img_tensor = tf.squeeze(img_batch, 0)
+    img_tensor = tf.cast(img_tensor, tf.float32)
+    labels = tf.ones(shape=(tf.shape(boxes)[0], ), dtype=tf.int32) * draw_box_in_img.ONLY_DRAW_BOXES
+    scores = tf.zeros_like(labels, dtype=tf.float32)
+    img_tensor_with_boxes = tf.py_func(draw_box_in_img.draw_boxes_with_label_and_scores,
+                                       inp=[img_tensor, boxes, labels, scores],
+                                       Tout=tf.uint8)
+    img_tensor_with_boxes = tf.reshape(img_tensor_with_boxes, tf.shape(img_batch))  # [batch_size, h, w, c]
+
+    return img_tensor_with_boxes
+
+def draw_boxes_with_scores(img_batch, boxes, scores):
+
+    boxes = tf.stop_gradient(boxes)
+    scores = tf.stop_gradient(scores)
+
+    img_tensor = tf.squeeze(img_batch, 0)
+    img_tensor = tf.cast(img_tensor, tf.float32)
+    labels = tf.ones(shape=(tf.shape(boxes)[0],), dtype=tf.int32) * draw_box_in_img.ONLY_DRAW_BOXES_WITH_SCORES
+    img_tensor_with_boxes = tf.py_func(draw_box_in_img.draw_boxes_with_label_and_scores,
+                                       inp=[img_tensor, boxes, labels, scores],
+                                       Tout=[tf.uint8])
+    img_tensor_with_boxes = tf.reshape(img_tensor_with_boxes, tf.shape(img_batch))
+    return img_tensor_with_boxes
+
+def draw_boxes_with_categories(img_batch, boxes, labels):
+    boxes = tf.stop_gradient(boxes)
+
+    img_tensor = tf.squeeze(img_batch, 0)
+    img_tensor = tf.cast(img_tensor, tf.float32)
+    scores = tf.ones(shape=(tf.shape(boxes)[0],), dtype=tf.float32)
+    img_tensor_with_boxes = tf.py_func(draw_box_in_img.draw_boxes_with_label_and_scores,
+                                       inp=[img_tensor, boxes, labels, scores],
+                                       Tout=[tf.uint8])
+    img_tensor_with_boxes = tf.reshape(img_tensor_with_boxes, tf.shape(img_batch))
+    return img_tensor_with_boxes
+
+def draw_boxes_with_categories_and_scores(img_batch, boxes, labels, scores):
+    boxes = tf.stop_gradient(boxes)
+    scores = tf.stop_gradient(scores)
+
+    img_tensor = tf.squeeze(img_batch, 0)
+    img_tensor = tf.cast(img_tensor, tf.float32)
+    img_tensor_with_boxes = tf.py_func(draw_box_in_img.draw_boxes_with_label_and_scores,
+                                       inp=[img_tensor, boxes, labels, scores],
+                                       Tout=[tf.uint8])
+    img_tensor_with_boxes = tf.reshape(img_tensor_with_boxes, tf.shape(img_batch))
+    return img_tensor_with_boxes
+
+if __name__ == "__main__":
+    print (1)
+
diff --git a/example-apps/PDD/pcb-defect-detection/libs/box_utils/tf_ops.py b/example-apps/PDD/pcb-defect-detection/libs/box_utils/tf_ops.py
new file mode 100755
index 0000000..86d945a
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/box_utils/tf_ops.py
@@ -0,0 +1,57 @@
+# -*- coding:utf-8 -*-
+
+from __future__ import absolute_import, print_function, division
+
+import tensorflow as tf
+
+'''
+all of these ops are derived from tenosrflow Object Detection API
+'''
+def indices_to_dense_vector(indices,
+                            size,
+                            indices_value=1.,
+                            default_value=0,
+                            dtype=tf.float32):
+  """Creates dense vector with indices set to specific (the para "indices_value" ) and rest to zeros.
+
+  This function exists because it is unclear if it is safe to use
+    tf.sparse_to_dense(indices, [size], 1, validate_indices=False)
+  with indices which are not ordered.
+  This function accepts a dynamic size (e.g. tf.shape(tensor)[0])
+
+  Args:
+    indices: 1d Tensor with integer indices which are to be set to
+        indices_values.
+    size: scalar with size (integer) of output Tensor.
+    indices_value: values of elements specified by indices in the output vector
+    default_value: values of other elements in the output vector.
+    dtype: data type.
+
+  Returns:
+    dense 1D Tensor of shape [size] with indices set to indices_values and the
+        rest set to default_value.
+  """
+  size = tf.to_int32(size)
+  zeros = tf.ones([size], dtype=dtype) * default_value
+  values = tf.ones_like(indices, dtype=dtype) * indices_value
+
+  return tf.dynamic_stitch([tf.range(size), tf.to_int32(indices)],
+                           [zeros, values])
+
+
+
+
+def test_plt():
+  from PIL import Image
+  import matplotlib.pyplot as plt
+  import numpy as np
+
+  a = np.random.rand(20, 30)
+  print (a.shape)
+  # plt.subplot()
+  b = plt.imshow(a)
+  plt.show()
+
+
+if __name__ == '__main__':
+  test_plt()
diff --git a/example-apps/PDD/pcb-defect-detection/libs/configs/__init__.py b/example-apps/PDD/pcb-defect-detection/libs/configs/__init__.py
new file mode 100755
index 0000000..e69de29
diff --git a/example-apps/PDD/pcb-defect-detection/libs/configs/cfgs.py b/example-apps/PDD/pcb-defect-detection/libs/configs/cfgs.py
new file mode 100755
index 0000000..93049eb
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/configs/cfgs.py
@@ -0,0 +1,133 @@
+# -*- coding: utf-8 -*-
+from __future__ import division, print_function, absolute_import
+import os
+import tensorflow as tf
+# ------------------------------------------------
+VERSION = 'FPN_Res101_0117_OHEM'
+NET_NAME = 'resnet_v1_101'
+ADD_BOX_IN_TENSORBOARD = True
+
+# ---------------------------------------- System_config
+ROOT_PATH = os.path.abspath('../')
+print (20*"++--")
+print (ROOT_PATH)
+GPU_GROUP = "2"
+SHOW_TRAIN_INFO_INTE = 10
+SMRY_ITER = 100
+SAVE_WEIGHTS_INTE = 10000
+
+SUMMARY_PATH = ROOT_PATH + '/output/summary'
+TEST_SAVE_PATH = ROOT_PATH + '/tools/test_result'
+INFERENCE_IMAGE_PATH = ROOT_PATH + '/tools/inference_image'
+INFERENCE_SAVE_PATH = ROOT_PATH + '/tools/inference_results'
+
+if NET_NAME.startswith("resnet"):
+    weights_name = NET_NAME
+elif NET_NAME.startswith("MobilenetV2"):
+    weights_name = "mobilenet/mobilenet_v2_1.0_224"
+else:
+    raise NotImplementedError
+
+PRETRAINED_CKPT = ROOT_PATH + '/data/pretrained_weights/' + weights_name + '.ckpt'
+TRAINED_CKPT = os.path.join(ROOT_PATH, 'output/trained_weights')
+
+EVALUATE_DIR = ROOT_PATH + '/output/evaluate_result_pickle/'
+#test_annotate_path = '/home/yjr/DataSet/VOC/VOC_test/VOC2007/Annotations'
+test_annotate_path = ROOT_PATH + '/data/pcb_train/Annotations'
+# ------------------------------------------ Train config
+RESTORE_FROM_RPN = False
+IS_FILTER_OUTSIDE_BOXES = False
+FIXED_BLOCKS = 0  # allow 0~3
+USE_07_METRIC = False
+
+RPN_LOCATION_LOSS_WEIGHT = 1.
+RPN_CLASSIFICATION_LOSS_WEIGHT = 1.0
+
+FAST_RCNN_LOCATION_LOSS_WEIGHT = 1.0
+FAST_RCNN_CLASSIFICATION_LOSS_WEIGHT = 1.0
+RPN_SIGMA = 3.0
+FASTRCNN_SIGMA = 1.0
+
+MUTILPY_BIAS_GRADIENT = None   # 2.0  # if None, will not multipy
+GRADIENT_CLIPPING_BY_NORM = None   # 10.0  if None, will not clip
+
+EPSILON = 1e-5
+MOMENTUM = 0.9
+LR = 0.001  # 0.001  # 0.0003
+#DECAY_STEP = [60000, 80000]  # 50000, 70000
+DECAY_STEP = [10000, 20000]  # 50000, 70000
+#MAX_ITERATION = 150000
+MAX_ITERATION = 30000
+
+# ------------------------------------------- Data_preprocess_config
+DATASET_NAME = 'pcb'  # 'ship', 'spacenet', 'pascal', 'coco'
+# PIXEL_MEAN = [123.68, 116.779, 103.939]  # R, G, B. In tf, channel is RGB. In openCV, channel is BGR
+PIXEL_MEAN = [21.25, 85.936, 28.729]
+IMG_SHORT_SIDE_LEN =  600  # 600
+IMG_MAX_LENGTH =  3000  # 1000
+CLASS_NUM = 6
+
+# --------------------------------------------- Network_config
+BATCH_SIZE = 1
+INITIALIZER = tf.random_normal_initializer(mean=0.0, stddev=0.01)
+BBOX_INITIALIZER = tf.random_normal_initializer(mean=0.0, stddev=0.001)
+WEIGHT_DECAY = 0.00004 if NET_NAME.startswith('Mobilenet') else 0.0001
+
+# ---------------------------------------------Anchor config
+USE_CENTER_OFFSET = False
+
+LEVLES = ['P2', 'P3', 'P4', 'P5', 'P6']
+# BASE_ANCHOR_SIZE_LIST = [32, 64, 128, 256, 512]  # addjust the base anchor size for voc.
+BASE_ANCHOR_SIZE_LIST = [15, 25, 40, 60, 80]  # addjust the base anchor size for voc.
+#BASE_ANCHOR_SIZE_LIST = [8, 15, 25, 40, 60]
+ANCHOR_STRIDE_LIST = [4, 8, 16, 32, 64]
+ANCHOR_SCALES = [2., 3., 4.]
+ANCHOR_RATIOS = [2., 3., 4., 5.]
+# ANCHOR_SCALES = [1.0]
+# ANCHOR_RATIOS = [0.5, 1., 2.0]
+ROI_SCALE_FACTORS = [10., 10., 5.0, 5.0]
+ANCHOR_SCALE_FACTORS = None
+
+# --------------------------------------------FPN config
+SHARE_HEADS = True
+KERNEL_SIZE = 3
+RPN_IOU_POSITIVE_THRESHOLD = 0.7
+RPN_IOU_NEGATIVE_THRESHOLD = 0.3
+TRAIN_RPN_CLOOBER_POSITIVES = False
+
+RPN_MINIBATCH_SIZE = 256
+RPN_POSITIVE_RATE = 0.5
+RPN_NMS_IOU_THRESHOLD = 0.7
+RPN_TOP_K_NMS_TRAIN = 12000
+#RPN_MAXIMUM_PROPOSAL_TARIN = 2000
+RPN_MAXIMUM_PROPOSAL_TARIN = 2000
+
+RPN_TOP_K_NMS_TEST = 6000
+RPN_MAXIMUM_PROPOSAL_TEST = 1000
+
+# specific settings for FPN
+# FPN_TOP_K_PER_LEVEL_TRAIN = 2000
+# FPN_TOP_K_PER_LEVEL_TEST = 1000
+
+# -------------------------------------------Fast-RCNN config
+ROI_SIZE = 14
+ROI_POOL_KERNEL_SIZE = 2
+#USE_DROPOUT = False
+USE_DROPOUT = True
+KEEP_PROB = 1.0
+SHOW_SCORE_THRSHOLD = 0.6  # only show in tensorboard
+
+#FAST_RCNN_NMS_IOU_THRESHOLD = 0.3  # 0.6
+FAST_RCNN_NMS_IOU_THRESHOLD = 0.3
+FAST_RCNN_NMS_MAX_BOXES_PER_CLASS = 100
+FAST_RCNN_IOU_POSITIVE_THRESHOLD = 0.5
+FAST_RCNN_IOU_NEGATIVE_THRESHOLD = 0.0   # 0.1 < IOU < 0.5 is negative
+FAST_RCNN_MINIBATCH_SIZE = 256  # if is -1, that is train with OHEM
+# FAST_RCNN_MINIBATCH_SIZE = -1
+FAST_RCNN_POSITIVE_RATE = 0.25
+
+#ADD_GTBOXES_TO_TRAIN = False
+ADD_GTBOXES_TO_TRAIN = True
+
+
+
diff --git a/example-apps/PDD/pcb-defect-detection/libs/configs/cfgs_res101_fpn.py b/example-apps/PDD/pcb-defect-detection/libs/configs/cfgs_res101_fpn.py
new file mode 100755
index 0000000..d9daad2
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/configs/cfgs_res101_fpn.py
@@ -0,0 +1,212 @@
+# -*- coding: utf-8 -*-
+from __future__ import division, print_function, absolute_import
+import os
+import tensorflow as tf
+'''
+cls : person|| Recall: 0.9200530035335689 || Precison: 0.009050166947990866|| AP: 0.8413662097687251
+____________________
+cls : cat|| Recall: 0.9608938547486033 || Precison: 0.0007414480221227399|| AP: 0.886410933036462
+____________________
+cls : horse|| Recall: 0.9626436781609196 || Precison: 0.0007370072226707821|| AP: 0.880462817781879
+____________________
+cls : boat|| Recall: 0.8783269961977186 || Precison: 0.000509740231082238|| AP: 0.6456185469835614
+____________________
+cls : bottle|| Recall: 0.8656716417910447 || Precison: 0.0008665714718695106|| AP: 0.6480626365413494
+____________________
+cls : bicycle|| Recall: 0.9228486646884273 || Precison: 0.0006832296772124229|| AP: 0.8550508887926864
+____________________
+cls : bus|| Recall: 0.9577464788732394 || Precison: 0.00045156820340048565|| AP: 0.8631526839193041
+____________________
+cls : sheep|| Recall: 0.9132231404958677 || Precison: 0.0004864327094081809|| AP: 0.7741568397678364
+____________________
+cls : car|| Recall: 0.9600333055786844 || Precison: 0.0025449055537652685|| AP: 0.8914023804170609
+____________________
+cls : motorbike|| Recall: 0.9538461538461539 || Precison: 0.0006737519288865706|| AP: 0.8495072139551133
+____________________
+cls : chair|| Recall: 0.873015873015873 || Precison: 0.001433311906044233|| AP: 0.5759698175528438
+____________________
+cls : aeroplane|| Recall: 0.9438596491228071 || Precison: 0.0006024690030817745|| AP: 0.8353670052573003
+____________________
+cls : tvmonitor|| Recall: 0.9415584415584416 || Precison: 0.0006278089036291684|| AP: 0.7613581746623427
+____________________
+cls : sofa|| Recall: 0.9707112970711297 || Precison: 0.0005222178954168627|| AP: 0.7987407803525022
+____________________
+cls : bird|| Recall: 0.9281045751633987 || Precison: 0.0009227090390830091|| AP: 0.8159836473038345
+____________________
+cls : dog|| Recall: 0.9611451942740287 || Precison: 0.0010255447933963644|| AP: 0.8951754362513265
+____________________
+cls : cow|| Recall: 0.9467213114754098 || Precison: 0.0005056795917786568|| AP: 0.8497306852549179
+____________________
+cls : diningtable|| Recall: 0.883495145631068 || Precison: 0.0004040099093419522|| AP: 0.7307392356452687
+____________________
+cls : pottedplant|| Recall: 0.7729166666666667 || Precison: 0.0008064077902035582|| AP: 0.4738700691112566
+____________________
+cls : train|| Recall: 0.9290780141843972 || Precison: 0.0005804331981204598|| AP: 0.8427500500899303
+____________________
+mAP is : 0.7857438026222752   (USE_12_METRIC)
+
+cls : train|| Recall: 0.9290780141843972 || Precison: 0.0005804331981204598|| AP: 0.8101152343436091
+____________________
+cls : bus|| Recall: 0.9577464788732394 || Precison: 0.00045156820340048565|| AP: 0.830722622273239
+____________________
+cls : chair|| Recall: 0.873015873015873 || Precison: 0.001433311906044233|| AP: 0.5698849842652579
+____________________
+cls : pottedplant|| Recall: 0.7729166666666667 || Precison: 0.0008064077902035582|| AP: 0.48047763621440476
+____________________
+cls : horse|| Recall: 0.9626436781609196 || Precison: 0.0007370072226707821|| AP: 0.8512804991519783
+____________________
+cls : person|| Recall: 0.9200530035335689 || Precison: 0.009050166947990866|| AP: 0.8107708491164711
+____________________
+cls : bottle|| Recall: 0.8656716417910447 || Precison: 0.0008665714718695106|| AP: 0.63789938616088
+____________________
+cls : bicycle|| Recall: 0.9228486646884273 || Precison: 0.0006832296772124229|| AP: 0.8166723684624742
+____________________
+cls : dog|| Recall: 0.9611451942740287 || Precison: 0.0010255447933963644|| AP: 0.864470680916449
+____________________
+cls : diningtable|| Recall: 0.883495145631068 || Precison: 0.0004040099093419522|| AP: 0.7122255048941863
+____________________
+cls : bird|| Recall: 0.9281045751633987 || Precison: 0.0009227090390830091|| AP: 0.7832546811459113
+____________________
+cls : sofa|| Recall: 0.9707112970711297 || Precison: 0.0005222178954168627|| AP: 0.778305908921783
+____________________
+cls : sheep|| Recall: 0.9132231404958677 || Precison: 0.0004864327094081809|| AP: 0.7463330859344937
+____________________
+cls : boat|| Recall: 0.8783269961977186 || Precison: 0.000509740231082238|| AP: 0.6291419623367831
+____________________
+cls : car|| Recall: 0.9600333055786844 || Precison: 0.0025449055537652685|| AP: 0.8630428431995184
+____________________
+cls : motorbike|| Recall: 0.9538461538461539 || Precison: 0.0006737519288865706|| AP: 0.8224280778332824
+____________________
+cls : aeroplane|| Recall: 0.9438596491228071 || Precison: 0.0006024690030817745|| AP: 0.8001448356711514
+____________________
+cls : cat|| Recall: 0.9608938547486033 || Precison: 0.0007414480221227399|| AP: 0.8582414148566436
+____________________
+cls : cow|| Recall: 0.9467213114754098 || Precison: 0.0005056795917786568|| AP: 0.8242904910827928
+____________________
+cls : tvmonitor|| Recall: 0.9415584415584416 || Precison: 0.0006278089036291684|| AP: 0.7388745216642896
+____________________
+mAP is : 0.76142887942228   (USE_07_METRIC)
+
+'''
+
+# ------------------------------------------------
+VERSION = 'FPN_Res101_20181204'
+NET_NAME = 'resnet_v1_101'
+ADD_BOX_IN_TENSORBOARD = True
+
+# ---------------------------------------- System_config
+ROOT_PATH = os.path.abspath('../')
+print (20*"++--")
+print (ROOT_PATH)
+GPU_GROUP = "4"
+SHOW_TRAIN_INFO_INTE = 10
+SMRY_ITER = 100
+SAVE_WEIGHTS_INTE = 10000
+
+SUMMARY_PATH = ROOT_PATH + '/output/summary'
+TEST_SAVE_PATH = ROOT_PATH + '/tools/test_result'
+INFERENCE_IMAGE_PATH = ROOT_PATH + '/tools/inference_image'
+INFERENCE_SAVE_PATH = ROOT_PATH + '/tools/inference_results'
+
+if NET_NAME.startswith("resnet"):
+    weights_name = NET_NAME
+elif NET_NAME.startswith("MobilenetV2"):
+    weights_name = "mobilenet/mobilenet_v2_1.0_224"
+else:
+    raise NotImplementedError
+
+PRETRAINED_CKPT = ROOT_PATH + '/data/pretrained_weights/' + weights_name + '.ckpt'
+TRAINED_CKPT = os.path.join(ROOT_PATH, 'output/trained_weights')
+
+EVALUATE_DIR = ROOT_PATH + '/output/evaluate_result_pickle/'
+#test_annotate_path = '/home/yjr/DataSet/VOC/VOC_test/VOC2007/Annotations'
+test_annotate_path = '/home/gq123/dailinhui/FPN_success_dlh/data/pcb/Annotations'
+
+# ------------------------------------------ Train config
+RESTORE_FROM_RPN = False
+IS_FILTER_OUTSIDE_BOXES = False
+FIXED_BLOCKS = 0  # allow 0~3
+USE_07_METRIC = False
+
+RPN_LOCATION_LOSS_WEIGHT = 1.
+RPN_CLASSIFICATION_LOSS_WEIGHT = 1.0
+
+FAST_RCNN_LOCATION_LOSS_WEIGHT = 1.0
+FAST_RCNN_CLASSIFICATION_LOSS_WEIGHT = 1.0
+RPN_SIGMA = 3.0
+FASTRCNN_SIGMA = 1.0
+
+MUTILPY_BIAS_GRADIENT = None   # 2.0  # if None, will not multipy
+GRADIENT_CLIPPING_BY_NORM = None   # 10.0  if None, will not clip
+
+EPSILON = 1e-5
+MOMENTUM = 0.9
+LR = 0.001  # 0.001  # 0.0003
+#DECAY_STEP = [60000, 80000]  # 50000, 70000
+DECAY_STEP = [1000, 1500]  # 50000, 70000
+#MAX_ITERATION = 150000
+MAX_ITERATION = 2000
+
+# ------------------------------------------- Data_preprocess_config
+DATASET_NAME = 'pcb'  # 'ship', 'spacenet', 'pascal', 'coco'
+#PIXEL_MEAN = [123.68, 116.779, 103.939]  # R, G, B. In tf, channel is RGB. In openCV, channel is BGR
+PIXEL_MEAN = [21.25, 85.936, 28.729]
+IMG_SHORT_SIDE_LEN = 1586  # 600  # 600
+IMG_MAX_LENGTH = 3034  # 1000  # 1000
+CLASS_NUM = 6
+
+# --------------------------------------------- Network_config
+BATCH_SIZE = 1
+INITIALIZER = tf.random_normal_initializer(mean=0.0, stddev=0.01)
+BBOX_INITIALIZER = tf.random_normal_initializer(mean=0.0, stddev=0.001)
+WEIGHT_DECAY = 0.00004 if NET_NAME.startswith('Mobilenet') else 0.0001
+
+# ---------------------------------------------Anchor config
+USE_CENTER_OFFSET = False
+
+LEVLES = ['P2', 'P3', 'P4', 'P5', 'P6']
+BASE_ANCHOR_SIZE_LIST = [32, 64, 128, 256, 512]  # addjust the base anchor size for voc.
+ANCHOR_STRIDE_LIST = [4, 8, 16, 32, 64]
+ANCHOR_SCALES = [1.0]
+ANCHOR_RATIOS = [0.5, 1., 2.0]
+ROI_SCALE_FACTORS = [10., 10., 5.0, 5.0]
+ANCHOR_SCALE_FACTORS = None
+
+# --------------------------------------------FPN config
+SHARE_HEADS = True
+KERNEL_SIZE = 3
+RPN_IOU_POSITIVE_THRESHOLD = 0.7
+RPN_IOU_NEGATIVE_THRESHOLD = 0.3
+TRAIN_RPN_CLOOBER_POSITIVES = False
+
+RPN_MINIBATCH_SIZE = 256
+RPN_POSITIVE_RATE = 0.5
+RPN_NMS_IOU_THRESHOLD = 0.7
+RPN_TOP_K_NMS_TRAIN = 12000
+RPN_MAXIMUM_PROPOSAL_TARIN = 2000
+
+RPN_TOP_K_NMS_TEST = 6000
+RPN_MAXIMUM_PROPOSAL_TEST = 1000
+
+# specific settings for FPN
+# FPN_TOP_K_PER_LEVEL_TRAIN = 2000
+# FPN_TOP_K_PER_LEVEL_TEST = 1000
+
+# -------------------------------------------Fast-RCNN config
+ROI_SIZE = 14
+ROI_POOL_KERNEL_SIZE = 2
+USE_DROPOUT = False
+KEEP_PROB = 1.0
+SHOW_SCORE_THRSHOLD = 0.6  # only show in tensorboard
+
+FAST_RCNN_NMS_IOU_THRESHOLD = 0.3  # 0.6
+FAST_RCNN_NMS_MAX_BOXES_PER_CLASS = 100
+FAST_RCNN_IOU_POSITIVE_THRESHOLD = 0.5
+FAST_RCNN_IOU_NEGATIVE_THRESHOLD = 0.0   # 0.1 < IOU < 0.5 is negative
+FAST_RCNN_MINIBATCH_SIZE = 256  # if is -1, that is train with OHEM
+FAST_RCNN_POSITIVE_RATE = 0.25
+
+ADD_GTBOXES_TO_TRAIN = False
+
+
+
diff --git a/example-apps/PDD/pcb-defect-detection/libs/configs/cfgs_res101_fpn_v1.py b/example-apps/PDD/pcb-defect-detection/libs/configs/cfgs_res101_fpn_v1.py
new file mode 100755
index 0000000..15b95f1
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/configs/cfgs_res101_fpn_v1.py
@@ -0,0 +1,125 @@
+# -*- coding: utf-8 -*-
+from __future__ import division, print_function, absolute_import
+import os
+import tensorflow as tf
+'''
+
+'''
+
+# ------------------------------------------------
+VERSION = 'FPN_Res101_20181201_v1'
+NET_NAME = 'resnet_v1_101'
+ADD_BOX_IN_TENSORBOARD = True
+
+# ---------------------------------------- System_config
+ROOT_PATH = os.path.abspath('../')
+print (20*"++--")
+print (ROOT_PATH)
+GPU_GROUP = "2"
+SHOW_TRAIN_INFO_INTE = 10
+SMRY_ITER = 100
+SAVE_WEIGHTS_INTE = 10000
+
+SUMMARY_PATH = ROOT_PATH + '/output/summary'
+TEST_SAVE_PATH = ROOT_PATH + '/tools/test_result'
+INFERENCE_IMAGE_PATH = ROOT_PATH + '/tools/inference_image'
+INFERENCE_SAVE_PATH = ROOT_PATH + '/tools/inference_results'
+
+if NET_NAME.startswith("resnet"):
+    weights_name = NET_NAME
+elif NET_NAME.startswith("MobilenetV2"):
+    weights_name = "mobilenet/mobilenet_v2_1.0_224"
+else:
+    raise NotImplementedError
+
+PRETRAINED_CKPT = ROOT_PATH + '/data/pretrained_weights/' + weights_name + '.ckpt'
+TRAINED_CKPT = os.path.join(ROOT_PATH, 'output/trained_weights')
+
+EVALUATE_DIR = ROOT_PATH + '/output/evaluate_result_pickle/'
+test_annotate_path = '/home/yjr/DataSet/VOC/VOC_test/VOC2007/Annotations'
+
+# ------------------------------------------ Train config
+RESTORE_FROM_RPN = False
+IS_FILTER_OUTSIDE_BOXES = False
+FIXED_BLOCKS = 0  # allow 0~3
+USE_07_METRIC = False
+
+RPN_LOCATION_LOSS_WEIGHT = 1.
+RPN_CLASSIFICATION_LOSS_WEIGHT = 1.0
+
+FAST_RCNN_LOCATION_LOSS_WEIGHT = 1.0
+FAST_RCNN_CLASSIFICATION_LOSS_WEIGHT = 1.0
+RPN_SIGMA = 3.0
+FASTRCNN_SIGMA = 1.0
+
+MUTILPY_BIAS_GRADIENT = None   # 2.0  # if None, will not multipy
+GRADIENT_CLIPPING_BY_NORM = None   # 10.0  if None, will not clip
+
+EPSILON = 1e-5
+MOMENTUM = 0.9
+LR = 0.001  # 0.001  # 0.0003
+DECAY_STEP = [60000, 80000]  # 50000, 70000
+MAX_ITERATION = 150000
+
+# -------------------------------------------- Data_preprocess_config
+DATASET_NAME = 'pascal'  # 'ship', 'spacenet', 'pascal', 'coco'
+PIXEL_MEAN = [123.68, 116.779, 103.939]  # R, G, B. In tf, channel is RGB. In openCV, channel is BGR
+IMG_SHORT_SIDE_LEN = 800  # 600  # 600
+IMG_MAX_LENGTH = 1200  # 1000  # 1000
+CLASS_NUM = 20
+
+# --------------------------------------------- Network_config
+BATCH_SIZE = 1
+INITIALIZER = tf.random_normal_initializer(mean=0.0, stddev=0.01)
+BBOX_INITIALIZER = tf.random_normal_initializer(mean=0.0, stddev=0.001)
+WEIGHT_DECAY = 0.00004 if NET_NAME.startswith('Mobilenet') else 0.0001
+
+# ---------------------------------------------Anchor config
+USE_CENTER_OFFSET = False
+
+LEVLES = ['P2', 'P3', 'P4', 'P5', 'P6']
+BASE_ANCHOR_SIZE_LIST = [32, 64, 128, 256, 512]  # addjust the base anchor size for voc.
+ANCHOR_STRIDE_LIST = [4, 8, 16, 32, 64]
+ANCHOR_SCALES = [1.0]
+ANCHOR_RATIOS = [0.5, 1., 2.0]
+ROI_SCALE_FACTORS = [10., 10., 5.0, 5.0]
+ANCHOR_SCALE_FACTORS = None
+
+# --------------------------------------------FPN config
+SHARE_HEADS = True
+KERNEL_SIZE = 3
+RPN_IOU_POSITIVE_THRESHOLD = 0.7
+RPN_IOU_NEGATIVE_THRESHOLD = 0.3
+TRAIN_RPN_CLOOBER_POSITIVES = False
+
+RPN_MINIBATCH_SIZE = 256
+RPN_POSITIVE_RATE = 0.5
+RPN_NMS_IOU_THRESHOLD = 0.7
+RPN_TOP_K_NMS_TRAIN = 12000
+RPN_MAXIMUM_PROPOSAL_TARIN = 2000
+
+RPN_TOP_K_NMS_TEST = 6000
+RPN_MAXIMUM_PROPOSAL_TEST = 1000
+
+# specific settings for FPN
+# FPN_TOP_K_PER_LEVEL_TRAIN = 2000
+# FPN_TOP_K_PER_LEVEL_TEST = 1000
+
+# -------------------------------------------Fast-RCNN config
+ROI_SIZE = 14
+ROI_POOL_KERNEL_SIZE = 2
+USE_DROPOUT = False
+KEEP_PROB = 1.0
+SHOW_SCORE_THRSHOLD = 0.5  # only show in tensorboard
+
+FAST_RCNN_NMS_IOU_THRESHOLD = 0.3  # 0.6
+FAST_RCNN_NMS_MAX_BOXES_PER_CLASS = 100
+FAST_RCNN_IOU_POSITIVE_THRESHOLD = 0.5
+FAST_RCNN_IOU_NEGATIVE_THRESHOLD = 0.0   # 0.1 < IOU < 0.5 is negative
+FAST_RCNN_MINIBATCH_SIZE = 512  # if is -1, that is train with OHEM
+FAST_RCNN_POSITIVE_RATE = 0.25
+
+ADD_GTBOXES_TO_TRAIN = False
+
+
+
diff --git a/example-apps/PDD/pcb-defect-detection/libs/configs/cfgs_res101_fpn_v2.py b/example-apps/PDD/pcb-defect-detection/libs/configs/cfgs_res101_fpn_v2.py
new file mode 100755
index 0000000..963df61
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/configs/cfgs_res101_fpn_v2.py
@@ -0,0 +1,208 @@
+# -*- coding: utf-8 -*-
+from __future__ import division, print_function, absolute_import
+import os
+import tensorflow as tf
+
+"""
+cls : car|| Recall: 0.9542048293089093 || Precison: 0.002486730925298256|| AP: 0.8861557852184543
+____________________
+cls : aeroplane|| Recall: 0.9333333333333333 || Precison: 0.0005925041542114572|| AP: 0.842025283046165
+____________________
+cls : diningtable|| Recall: 0.8932038834951457 || Precison: 0.00040969553387335954|| AP: 0.7380756727563009
+____________________
+cls : cow|| Recall: 0.9672131147540983 || Precison: 0.0005127837421479989|| AP: 0.8598673192007477
+____________________
+cls : boat|| Recall: 0.870722433460076 || Precison: 0.0005048556531707801|| AP: 0.614924861322453
+____________________
+cls : person|| Recall: 0.9112190812720848 || Precison: 0.00890183387270766|| AP: 0.8403573910074297
+____________________
+cls : bottle|| Recall: 0.8550106609808102 || Precison: 0.0008528612324589202|| AP: 0.6431100249936452
+____________________
+cls : bus|| Recall: 0.9624413145539906 || Precison: 0.00045113940207524124|| AP: 0.8462278674877455
+____________________
+cls : chair|| Recall: 0.8465608465608465 || Precison: 0.0013795928045612787|| AP: 0.5683751395230314
+____________________
+cls : train|| Recall: 0.9361702127659575 || Precison: 0.0005837401825514753|| AP: 0.8364460305413468
+____________________
+cls : dog|| Recall: 0.9754601226993865 || Precison: 0.0010383537847668929|| AP: 0.9033364857501106
+____________________
+cls : motorbike|| Recall: 0.92 || Precison: 0.0006513139551094382|| AP: 0.8295629935581179
+____________________
+cls : cat|| Recall: 0.9608938547486033 || Precison: 0.0007397197236372707|| AP: 0.8871965890034861
+____________________
+cls : sofa|| Recall: 0.9539748953974896 || Precison: 0.0005096076691483964|| AP: 0.8040267075520897
+____________________
+cls : bird|| Recall: 0.9150326797385621 || Precison: 0.0009065830883400464|| AP: 0.8237404489482196
+____________________
+cls : horse|| Recall: 0.9568965517241379 || Precison: 0.0007317362585204424|| AP: 0.8735567893480496
+____________________
+cls : pottedplant|| Recall: 0.7895833333333333 || Precison: 0.0008196455411498826|| AP: 0.4870711669635938
+____________________
+cls : bicycle|| Recall: 0.9109792284866469 || Precison: 0.0006712950308861314|| AP: 0.8361496835573192
+____________________
+cls : tvmonitor|| Recall: 0.9512987012987013 || Precison: 0.0006329305331737686|| AP: 0.7944641602539069
+____________________
+cls : sheep|| Recall: 0.9214876033057852 || Precison: 0.0004898504308706817|| AP: 0.7823429444259854
+____________________
+mAP is : 0.7848506672229101    USE_12_METRIC
+
+cls : tvmonitor|| Recall: 0.9512987012987013 || Precison: 0.0006329305331737686|| AP: 0.7680923930233127
+____________________
+cls : sheep|| Recall: 0.9214876033057852 || Precison: 0.0004898504308706817|| AP: 0.7605331894258903
+____________________
+cls : cat|| Recall: 0.9608938547486033 || Precison: 0.0007397197236372707|| AP: 0.8561115936556246
+____________________
+cls : train|| Recall: 0.9361702127659575 || Precison: 0.0005837401825514753|| AP: 0.7978443126776701
+____________________
+cls : aeroplane|| Recall: 0.9333333333333333 || Precison: 0.0005925041542114572|| AP: 0.8033498986573708
+____________________
+cls : motorbike|| Recall: 0.92 || Precison: 0.0006513139551094382|| AP: 0.7991141448766482
+____________________
+cls : bus|| Recall: 0.9624413145539906 || Precison: 0.00045113940207524124|| AP: 0.8181027979596772
+____________________
+cls : bird|| Recall: 0.9150326797385621 || Precison: 0.0009065830883400464|| AP: 0.7851247014320806
+____________________
+cls : pottedplant|| Recall: 0.7895833333333333 || Precison: 0.0008196455411498826|| AP: 0.49033575375142174
+____________________
+cls : cow|| Recall: 0.9672131147540983 || Precison: 0.0005127837421479989|| AP: 0.8304367006298838
+____________________
+cls : person|| Recall: 0.9112190812720848 || Precison: 0.00890183387270766|| AP: 0.797530517185023
+____________________
+cls : bottle|| Recall: 0.8550106609808102 || Precison: 0.0008528612324589202|| AP: 0.6320745719617634
+____________________
+cls : sofa|| Recall: 0.9539748953974896 || Precison: 0.0005096076691483964|| AP: 0.7868518534567335
+____________________
+cls : boat|| Recall: 0.870722433460076 || Precison: 0.0005048556531707801|| AP: 0.6036612374959088
+____________________
+cls : car|| Recall: 0.9542048293089093 || Precison: 0.002486730925298256|| AP: 0.8623955910304107
+____________________
+cls : bicycle|| Recall: 0.9109792284866469 || Precison: 0.0006712950308861314|| AP: 0.8029062441256611
+____________________
+cls : dog|| Recall: 0.9754601226993865 || Precison: 0.0010383537847668929|| AP: 0.8661350949646617
+____________________
+cls : diningtable|| Recall: 0.8932038834951457 || Precison: 0.00040969553387335954|| AP: 0.7127169697539509
+____________________
+cls : horse|| Recall: 0.9568965517241379 || Precison: 0.0007317362585204424|| AP: 0.8422342978325045
+____________________
+cls : chair|| Recall: 0.8465608465608465 || Precison: 0.0013795928045612787|| AP: 0.563170854101135
+____________________
+mAP is : 0.7589361358998666   USE_07_METRIC
+"""
+
+# ------------------------------------------------
+VERSION = 'FPN_Res101_20181201_v2'
+NET_NAME = 'resnet_v1_101'
+ADD_BOX_IN_TENSORBOARD = True
+
+# ---------------------------------------- System_config
+ROOT_PATH = os.path.abspath('../')
+print (20*"++--")
+print (ROOT_PATH)
+GPU_GROUP = "3"
+SHOW_TRAIN_INFO_INTE = 10
+SMRY_ITER = 100
+SAVE_WEIGHTS_INTE = 10000
+
+SUMMARY_PATH = ROOT_PATH + '/output/summary'
+TEST_SAVE_PATH = ROOT_PATH + '/tools/test_result'
+INFERENCE_IMAGE_PATH = ROOT_PATH + '/tools/inference_image'
+INFERENCE_SAVE_PATH = ROOT_PATH + '/tools/inference_results'
+
+if NET_NAME.startswith("resnet"):
+    weights_name = NET_NAME
+elif NET_NAME.startswith("MobilenetV2"):
+    weights_name = "mobilenet/mobilenet_v2_1.0_224"
+else:
+    raise NotImplementedError
+
+PRETRAINED_CKPT = ROOT_PATH + '/data/pretrained_weights/' + weights_name + '.ckpt'
+TRAINED_CKPT = os.path.join(ROOT_PATH, 'output/trained_weights')
+
+EVALUATE_DIR = ROOT_PATH + '/output/evaluate_result_pickle/'
+test_annotate_path = '/home/yjr/DataSet/VOC/VOC_test/VOC2007/Annotations'
+
+# ------------------------------------------ Train config
+RESTORE_FROM_RPN = False
+IS_FILTER_OUTSIDE_BOXES = False
+FIXED_BLOCKS = 0  # allow 0~3
+USE_07_METRIC = False
+
+RPN_LOCATION_LOSS_WEIGHT = 1.
+RPN_CLASSIFICATION_LOSS_WEIGHT = 1.0
+
+FAST_RCNN_LOCATION_LOSS_WEIGHT = 1.0
+FAST_RCNN_CLASSIFICATION_LOSS_WEIGHT = 1.0
+RPN_SIGMA = 3.0
+FASTRCNN_SIGMA = 1.0
+
+MUTILPY_BIAS_GRADIENT = None   # 2.0  # if None, will not multipy
+GRADIENT_CLIPPING_BY_NORM = None   # 10.0  if None, will not clip
+
+EPSILON = 1e-5
+MOMENTUM = 0.9
+LR = 0.001  # 0.001  # 0.0003
+DECAY_STEP = [60000, 80000]  # 50000, 70000
+MAX_ITERATION = 150000
+
+# -------------------------------------------- Data_preprocess_config
+DATASET_NAME = 'pascal'  # 'ship', 'spacenet', 'pascal', 'coco'
+PIXEL_MEAN = [123.68, 116.779, 103.939]  # R, G, B. In tf, channel is RGB. In openCV, channel is BGR
+IMG_SHORT_SIDE_LEN = 600  # 600  # 600
+IMG_MAX_LENGTH = 1000  # 1000  # 1000
+CLASS_NUM = 20
+
+# --------------------------------------------- Network_config
+BATCH_SIZE = 1
+INITIALIZER = tf.random_normal_initializer(mean=0.0, stddev=0.01)
+BBOX_INITIALIZER = tf.random_normal_initializer(mean=0.0, stddev=0.001)
+WEIGHT_DECAY = 0.00004 if NET_NAME.startswith('Mobilenet') else 0.0001
+
+# ---------------------------------------------Anchor config
+USE_CENTER_OFFSET = False
+
+LEVLES = ['P2', 'P3', 'P4', 'P5', 'P6']
+BASE_ANCHOR_SIZE_LIST = [32, 64, 128, 256, 512]  # addjust the base anchor size for voc.
+ANCHOR_STRIDE_LIST = [4, 8, 16, 32, 64]
+ANCHOR_SCALES = [1.0]
+ANCHOR_RATIOS = [0.5, 1., 2.0]
+ROI_SCALE_FACTORS = [10., 10., 5.0, 5.0]
+ANCHOR_SCALE_FACTORS = None
+
+# --------------------------------------------FPN config
+SHARE_HEADS = False
+KERNEL_SIZE = 3
+RPN_IOU_POSITIVE_THRESHOLD = 0.7
+RPN_IOU_NEGATIVE_THRESHOLD = 0.3
+TRAIN_RPN_CLOOBER_POSITIVES = False
+
+RPN_MINIBATCH_SIZE = 256
+RPN_POSITIVE_RATE = 0.5
+RPN_NMS_IOU_THRESHOLD = 0.7
+RPN_TOP_K_NMS_TRAIN = 12000
+RPN_MAXIMUM_PROPOSAL_TARIN = 2000
+
+RPN_TOP_K_NMS_TEST = 6000
+RPN_MAXIMUM_PROPOSAL_TEST = 1000
+
+# specific settings for FPN
+# FPN_TOP_K_PER_LEVEL_TRAIN = 2000
+# FPN_TOP_K_PER_LEVEL_TEST = 1000
+
+# -------------------------------------------Fast-RCNN config
+ROI_SIZE = 14
+ROI_POOL_KERNEL_SIZE = 2
+USE_DROPOUT = False
+KEEP_PROB = 1.0
+SHOW_SCORE_THRSHOLD = 0.5  # only show in tensorboard
+
+FAST_RCNN_NMS_IOU_THRESHOLD = 0.3  # 0.6
+FAST_RCNN_NMS_MAX_BOXES_PER_CLASS = 100
+FAST_RCNN_IOU_POSITIVE_THRESHOLD = 0.5
+FAST_RCNN_IOU_NEGATIVE_THRESHOLD = 0.0   # 0.1 < IOU < 0.5 is negative
+FAST_RCNN_MINIBATCH_SIZE = 256  # if is -1, that is train with OHEM
+FAST_RCNN_POSITIVE_RATE = 0.25
+
+ADD_GTBOXES_TO_TRAIN = False
+
+
+
diff --git a/example-apps/PDD/pcb-defect-detection/libs/configs/cfgs_res50_fpn.py b/example-apps/PDD/pcb-defect-detection/libs/configs/cfgs_res50_fpn.py
new file mode 100755
index 0000000..31f8eb1
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/configs/cfgs_res50_fpn.py
@@ -0,0 +1,208 @@
+# -*- coding: utf-8 -*-
+from __future__ import division, print_function, absolute_import
+import os
+import tensorflow as tf
+'''
+cls : aeroplane|| Recall: 0.9473684210526315 || Precison: 0.0006199030196164867|| AP: 0.826992691184208
+____________________
+cls : cow|| Recall: 0.9631147540983607 || Precison: 0.0005354526625668462|| AP: 0.8344652186720717
+____________________
+cls : dog|| Recall: 0.9652351738241309 || Precison: 0.0010528593384385115|| AP: 0.8848104631457077
+____________________
+cls : pottedplant|| Recall: 0.7708333333333334 || Precison: 0.000823124000293655|| AP: 0.4527288299945802
+____________________
+cls : diningtable|| Recall: 0.8980582524271845 || Precison: 0.00042887810125232407|| AP: 0.6700510019755388
+____________________
+cls : bird|| Recall: 0.9237472766884531 || Precison: 0.0009519832235409285|| AP: 0.7858394634006082
+____________________
+cls : tvmonitor|| Recall: 0.9415584415584416 || Precison: 0.0006423247726945524|| AP: 0.7532342429791412
+____________________
+cls : chair|| Recall: 0.8452380952380952 || Precison: 0.0014212159291838572|| AP: 0.5629849133883229
+____________________
+cls : train|| Recall: 0.925531914893617 || Precison: 0.0006022581218315107|| AP: 0.81368729431196
+____________________
+cls : horse|| Recall: 0.9454022988505747 || Precison: 0.0007562505602920185|| AP: 0.8603450848286776
+____________________
+cls : cat|| Recall: 0.9608938547486033 || Precison: 0.0007696817008175631|| AP: 0.8780370107529119
+____________________
+cls : sofa|| Recall: 0.9623430962343096 || Precison: 0.0005431753558979397|| AP: 0.748024582610825
+____________________
+cls : bottle|| Recall: 0.8571428571428571 || Precison: 0.0008744472166693132|| AP: 0.6253912291817303
+____________________
+cls : person|| Recall: 0.9149734982332155 || Precison: 0.009253199981238986|| AP: 0.8351147684067881
+____________________
+cls : car|| Recall: 0.9533721898417985 || Precison: 0.00259228066362385|| AP: 0.8841614814276471
+____________________
+cls : boat|| Recall: 0.8821292775665399 || Precison: 0.0005342347777629379|| AP: 0.6106671555293245
+____________________
+cls : motorbike|| Recall: 0.9323076923076923 || Precison: 0.0006731029825348658|| AP: 0.8421918380864666
+____________________
+cls : bicycle|| Recall: 0.9317507418397626 || Precison: 0.0007036524942688176|| AP: 0.8552669093308443
+____________________
+cls : bus|| Recall: 0.9765258215962441 || Precison: 0.00047651993823568495|| AP: 0.8420876315549962
+____________________
+cls : sheep|| Recall: 0.9049586776859504 || Precison: 0.000502333902950925|| AP: 0.7647489734437813
+____________________
+mAP is : 0.7665415392103065   USE_12_METRIC
+
+cls : bicycle|| Recall: 0.9317507418397626 || Precison: 0.0007036524942688176|| AP: 0.8298982119397122
+____________________
+cls : sofa|| Recall: 0.9623430962343096 || Precison: 0.0005431753558979397|| AP: 0.7272523895735249
+____________________
+cls : bus|| Recall: 0.9765258215962441 || Precison: 0.00047651993823568495|| AP: 0.8137027123104137
+____________________
+cls : diningtable|| Recall: 0.8980582524271845 || Precison: 0.00042887810125232407|| AP: 0.6530525394835751
+____________________
+cls : person|| Recall: 0.9149734982332155 || Precison: 0.009253199981238986|| AP: 0.803256081733613
+____________________
+cls : car|| Recall: 0.9533721898417985 || Precison: 0.00259228066362385|| AP: 0.8577825832291308
+____________________
+cls : boat|| Recall: 0.8821292775665399 || Precison: 0.0005342347777629379|| AP: 0.5979719282542533
+____________________
+cls : chair|| Recall: 0.8452380952380952 || Precison: 0.0014212159291838572|| AP: 0.5599343653732526
+____________________
+cls : aeroplane|| Recall: 0.9473684210526315 || Precison: 0.0006199030196164867|| AP: 0.7917730109896329
+____________________
+cls : cat|| Recall: 0.9608938547486033 || Precison: 0.0007696817008175631|| AP: 0.8475644227001603
+____________________
+cls : sheep|| Recall: 0.9049586776859504 || Precison: 0.000502333902950925|| AP: 0.7327379110779253
+____________________
+cls : train|| Recall: 0.925531914893617 || Precison: 0.0006022581218315107|| AP: 0.7743045860493956
+____________________
+cls : horse|| Recall: 0.9454022988505747 || Precison: 0.0007562505602920185|| AP: 0.8223412836194737
+____________________
+cls : cow|| Recall: 0.9631147540983607 || Precison: 0.0005354526625668462|| AP: 0.8058877343148467
+____________________
+cls : tvmonitor|| Recall: 0.9415584415584416 || Precison: 0.0006423247726945524|| AP: 0.7310441973657807
+____________________
+cls : pottedplant|| Recall: 0.7708333333333334 || Precison: 0.000823124000293655|| AP: 0.4646864671975241
+____________________
+cls : dog|| Recall: 0.9652351738241309 || Precison: 0.0010528593384385115|| AP: 0.8525619478862897
+____________________
+cls : bird|| Recall: 0.9237472766884531 || Precison: 0.0009519832235409285|| AP: 0.7610720209528306
+____________________
+cls : bottle|| Recall: 0.8571428571428571 || Precison: 0.0008744472166693132|| AP: 0.6127328834288011
+____________________
+cls : motorbike|| Recall: 0.9323076923076923 || Precison: 0.0006731029825348658|| AP: 0.8119378019468331
+____________________
+mAP is : 0.7425747539713485    USE_07_METRIC
+
+'''
+
+# ------------------------------------------------
+VERSION = 'FPN_Res50_20181201'
+NET_NAME = 'resnet_v1_50'
+ADD_BOX_IN_TENSORBOARD = True
+
+# ---------------------------------------- System_config
+ROOT_PATH = os.path.abspath('../')
+print (20*"++--")
+print (ROOT_PATH)
+GPU_GROUP = "1"
+SHOW_TRAIN_INFO_INTE = 10
+SMRY_ITER = 100
+SAVE_WEIGHTS_INTE = 10000
+
+SUMMARY_PATH = ROOT_PATH + '/output/summary'
+TEST_SAVE_PATH = ROOT_PATH + '/tools/test_result'
+INFERENCE_IMAGE_PATH = ROOT_PATH + '/tools/inference_image'
+INFERENCE_SAVE_PATH = ROOT_PATH + '/tools/inference_results'
+
+if NET_NAME.startswith("resnet"):
+    weights_name = NET_NAME
+elif NET_NAME.startswith("MobilenetV2"):
+    weights_name = "mobilenet/mobilenet_v2_1.0_224"
+else:
+    raise NotImplementedError
+
+PRETRAINED_CKPT = ROOT_PATH + '/data/pretrained_weights/' + weights_name + '.ckpt'
+TRAINED_CKPT = os.path.join(ROOT_PATH, 'output/trained_weights')
+
+EVALUATE_DIR = ROOT_PATH + '/output/evaluate_result_pickle/'
+test_annotate_path = '/home/yjr/DataSet/VOC/VOC_test/VOC2007/Annotations'
+
+# ------------------------------------------ Train config
+RESTORE_FROM_RPN = False
+IS_FILTER_OUTSIDE_BOXES = False
+FIXED_BLOCKS = 0  # allow 0~3
+USE_07_METRIC = False
+
+RPN_LOCATION_LOSS_WEIGHT = 1.
+RPN_CLASSIFICATION_LOSS_WEIGHT = 1.0
+
+FAST_RCNN_LOCATION_LOSS_WEIGHT = 1.0
+FAST_RCNN_CLASSIFICATION_LOSS_WEIGHT = 1.0
+RPN_SIGMA = 3.0
+FASTRCNN_SIGMA = 1.0
+
+MUTILPY_BIAS_GRADIENT = None   # 2.0  # if None, will not multipy
+GRADIENT_CLIPPING_BY_NORM = None   # 10.0  if None, will not clip
+
+EPSILON = 1e-5
+MOMENTUM = 0.9
+LR = 0.001  # 0.001  # 0.0003
+DECAY_STEP = [60000, 80000]  # 50000, 70000
+MAX_ITERATION = 150000
+
+# -------------------------------------------- Data_preprocess_config
+DATASET_NAME = 'pascal'  # 'ship', 'spacenet', 'pascal', 'coco'
+PIXEL_MEAN = [123.68, 116.779, 103.939]  # R, G, B. In tf, channel is RGB. In openCV, channel is BGR
+IMG_SHORT_SIDE_LEN = 600  # 600  # 600
+IMG_MAX_LENGTH = 1000  # 1000  # 1000
+CLASS_NUM = 20
+
+# --------------------------------------------- Network_config
+BATCH_SIZE = 1
+INITIALIZER = tf.random_normal_initializer(mean=0.0, stddev=0.01)
+BBOX_INITIALIZER = tf.random_normal_initializer(mean=0.0, stddev=0.001)
+WEIGHT_DECAY = 0.00004 if NET_NAME.startswith('Mobilenet') else 0.0001
+
+# ---------------------------------------------Anchor config
+USE_CENTER_OFFSET = False
+
+LEVLES = ['P2', 'P3', 'P4', 'P5', 'P6']
+BASE_ANCHOR_SIZE_LIST = [32, 64, 128, 256, 512]  # addjust the base anchor size for voc.
+ANCHOR_STRIDE_LIST = [4, 8, 16, 32, 64]
+ANCHOR_SCALES = [1.0]
+ANCHOR_RATIOS = [0.5, 1., 2.0]
+ROI_SCALE_FACTORS = [10., 10., 5.0, 5.0]
+ANCHOR_SCALE_FACTORS = None
+
+# --------------------------------------------FPN config
+SHARE_HEADS = True
+KERNEL_SIZE = 3
+RPN_IOU_POSITIVE_THRESHOLD = 0.7
+RPN_IOU_NEGATIVE_THRESHOLD = 0.3
+TRAIN_RPN_CLOOBER_POSITIVES = False
+
+RPN_MINIBATCH_SIZE = 256
+RPN_POSITIVE_RATE = 0.5
+RPN_NMS_IOU_THRESHOLD = 0.7
+RPN_TOP_K_NMS_TRAIN = 12000
+RPN_MAXIMUM_PROPOSAL_TARIN = 2000
+
+RPN_TOP_K_NMS_TEST = 6000
+RPN_MAXIMUM_PROPOSAL_TEST = 1000
+
+# specific settings for FPN
+# FPN_TOP_K_PER_LEVEL_TRAIN = 2000
+# FPN_TOP_K_PER_LEVEL_TEST = 1000
+
+# -------------------------------------------Fast-RCNN config
+ROI_SIZE = 14
+ROI_POOL_KERNEL_SIZE = 2
+USE_DROPOUT = False
+KEEP_PROB = 1.0
+SHOW_SCORE_THRSHOLD = 0.5  # only show in tensorboard
+
+FAST_RCNN_NMS_IOU_THRESHOLD = 0.3  # 0.6
+FAST_RCNN_NMS_MAX_BOXES_PER_CLASS = 100
+FAST_RCNN_IOU_POSITIVE_THRESHOLD = 0.5
+FAST_RCNN_IOU_NEGATIVE_THRESHOLD = 0.0   # 0.1 < IOU < 0.5 is negative
+FAST_RCNN_MINIBATCH_SIZE = 256  # if is -1, that is train with OHEM
+FAST_RCNN_POSITIVE_RATE = 0.25
+
+ADD_GTBOXES_TO_TRAIN = False
+
+
+
diff --git a/example-apps/PDD/pcb-defect-detection/libs/detection_oprations/__init__.py b/example-apps/PDD/pcb-defect-detection/libs/detection_oprations/__init__.py
new file mode 100755
index 0000000..e69de29
diff --git a/example-apps/PDD/pcb-defect-detection/libs/detection_oprations/anchor_target_layer_without_boxweight.py b/example-apps/PDD/pcb-defect-detection/libs/detection_oprations/anchor_target_layer_without_boxweight.py
new file mode 100755
index 0000000..6179bc0
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/detection_oprations/anchor_target_layer_without_boxweight.py
@@ -0,0 +1,125 @@
+# --------------------------------------------------------
+# Faster R-CNN
+# Copyright (c) 2015 Microsoft
+# Licensed under The MIT License [see LICENSE for details]
+# Written by Ross Girshick and Xinlei Chen
+# --------------------------------------------------------
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+from libs.configs import cfgs
+import numpy as np
+import numpy.random as npr
+from libs.box_utils.cython_utils.cython_bbox import bbox_overlaps
+from libs.box_utils import encode_and_decode
+
+
+def anchor_target_layer(
+        gt_boxes, img_shape, all_anchors, is_restrict_bg=False):
+    """Same as the anchor target layer in original Fast/er RCNN """
+
+    total_anchors = all_anchors.shape[0]
+    img_h, img_w = img_shape[1], img_shape[2]
+    gt_boxes = gt_boxes[:, :-1]  # remove class label
+
+
+    # allow boxes to sit over the edge by a small amount
+    _allowed_border = 0
+
+    # only keep anchors inside the image
+    if cfgs.IS_FILTER_OUTSIDE_BOXES:
+        inds_inside = np.where(
+            (all_anchors[:, 0] >= -_allowed_border) &
+            (all_anchors[:, 1] >= -_allowed_border) &
+            (all_anchors[:, 2] < img_w + _allowed_border) &  # width
+            (all_anchors[:, 3] < img_h + _allowed_border)  # height
+        )[0]
+    else:
+        inds_inside = range(all_anchors.shape[0])
+
+    anchors = all_anchors[inds_inside, :]
+
+    # label: 1 is positive, 0 is negative, -1 is dont care
+    labels = np.empty((len(inds_inside),), dtype=np.float32)
+    labels.fill(-1)
+
+    # overlaps between the anchors and the gt boxes
+    overlaps = bbox_overlaps(
+        np.ascontiguousarray(anchors, dtype=np.float),
+        np.ascontiguousarray(gt_boxes, dtype=np.float))
+
+    argmax_overlaps = overlaps.argmax(axis=1)
+    max_overlaps = overlaps[np.arange(len(inds_inside)), argmax_overlaps]
+    gt_argmax_overlaps = overlaps.argmax(axis=0)
+    gt_max_overlaps = overlaps[
+        gt_argmax_overlaps, np.arange(overlaps.shape[1])]
+    gt_argmax_overlaps = np.where(overlaps == gt_max_overlaps)[0]
+
+    if not cfgs.TRAIN_RPN_CLOOBER_POSITIVES:
+        labels[max_overlaps < cfgs.RPN_IOU_NEGATIVE_THRESHOLD] = 0
+
+    labels[gt_argmax_overlaps] = 1
+    labels[max_overlaps >= cfgs.RPN_IOU_POSITIVE_THRESHOLD] = 1
+
+    if cfgs.TRAIN_RPN_CLOOBER_POSITIVES:
+        labels[max_overlaps < cfgs.RPN_IOU_NEGATIVE_THRESHOLD] = 0
+
+    num_fg = int(cfgs.RPN_MINIBATCH_SIZE * cfgs.RPN_POSITIVE_RATE)
+    fg_inds = np.where(labels == 1)[0]
+    if len(fg_inds) > num_fg:
+        disable_inds = npr.choice(
+            fg_inds, size=(len(fg_inds) - num_fg), replace=False)
+        labels[disable_inds] = -1
+
+    num_bg = cfgs.RPN_MINIBATCH_SIZE - np.sum(labels == 1)
+    if is_restrict_bg:
+        num_bg = max(num_bg, num_fg * 1.5)
+    bg_inds = np.where(labels == 0)[0]
+    if len(bg_inds) > num_bg:
+        disable_inds = npr.choice(
+            bg_inds, size=(len(bg_inds) - num_bg), replace=False)
+        labels[disable_inds] = -1
+
+    bbox_targets = _compute_targets(anchors, gt_boxes[argmax_overlaps, :])
+
+    # map up to original set of anchors
+    labels = _unmap(labels, total_anchors, inds_inside, fill=-1)
+    bbox_targets = _unmap(bbox_targets, total_anchors, inds_inside, fill=0)
+
+    # labels = labels.reshape((1, height, width, A))
+    rpn_labels = labels.reshape((-1, 1))
+
+    # bbox_targets
+    bbox_targets = bbox_targets.reshape((-1, 4))
+    rpn_bbox_targets = bbox_targets
+
+    return rpn_labels, rpn_bbox_targets
+
+
+def _unmap(data, count, inds, fill=0):
+    """ Unmap a subset of item (data) back to the original set of items (of
+    size count) """
+    if len(data.shape) == 1:
+        ret = np.empty((count,), dtype=np.float32)
+        ret.fill(fill)
+        ret[inds] = data
+    else:
+        ret = np.empty((count,) + data.shape[1:], dtype=np.float32)
+        ret.fill(fill)
+        ret[inds, :] = data
+    return ret
+
+
+def _compute_targets(ex_rois, gt_rois):
+    """Compute bounding-box regression targets for an image."""
+    # targets = bbox_transform(ex_rois, gt_rois[:, :4]).astype(
+    #     np.float32, copy=False)
+    targets = encode_and_decode.encode_boxes(unencode_boxes=gt_rois,
+                                             reference_boxes=ex_rois,
+                                             scale_factors=cfgs.ANCHOR_SCALE_FACTORS)
+    # targets = encode_and_decode.encode_boxes(ex_rois=ex_rois,
+    #                                          gt_rois=gt_rois,
+    #                                          scale_factor=None)
+    return targets
diff --git a/example-apps/PDD/pcb-defect-detection/libs/detection_oprations/proposal_opr.py b/example-apps/PDD/pcb-defect-detection/libs/detection_oprations/proposal_opr.py
new file mode 100755
index 0000000..54cf9b8
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/detection_oprations/proposal_opr.py
@@ -0,0 +1,66 @@
+# encoding: utf-8
+"""
+@author: zeming li
+@contact: zengarden2009@gmail.com
+"""
+
+from libs.configs import cfgs
+from libs.box_utils import encode_and_decode
+from libs.box_utils import boxes_utils
+import tensorflow as tf
+import numpy as np
+
+
+def postprocess_rpn_proposals(rpn_bbox_pred, rpn_cls_prob, img_shape, anchors, is_training):
+    '''
+
+    :param rpn_bbox_pred: [-1, 4]
+    :param rpn_cls_prob: [-1, 2]
+    :param img_shape:
+    :param anchors:[-1, 4]
+    :param is_training:
+    :return:
+    '''
+
+    if is_training:
+        pre_nms_topN = cfgs.RPN_TOP_K_NMS_TRAIN
+        post_nms_topN = cfgs.RPN_MAXIMUM_PROPOSAL_TARIN
+        # pre_nms_topN = cfgs.FPN_TOP_K_PER_LEVEL_TRAIN
+        # post_nms_topN = pre_nms_topN
+    else:
+        pre_nms_topN = cfgs.RPN_TOP_K_NMS_TEST
+        post_nms_topN = cfgs.RPN_MAXIMUM_PROPOSAL_TEST
+        # pre_nms_topN = cfgs.FPN_TOP_K_PER_LEVEL_TEST
+        # post_nms_topN = pre_nms_topN
+
+    nms_thresh = cfgs.RPN_NMS_IOU_THRESHOLD
+
+    cls_prob = rpn_cls_prob[:, 1]
+
+    # 1. decode boxes
+    decode_boxes = encode_and_decode.decode_boxes(encoded_boxes=rpn_bbox_pred,
+                                                  reference_boxes=anchors,
+                                                  scale_factors=cfgs.ANCHOR_SCALE_FACTORS)
+
+    # 2. clip to img boundaries
+    decode_boxes = boxes_utils.clip_boxes_to_img_boundaries(decode_boxes=decode_boxes,
+                                                            img_shape=img_shape)
+
+    # 3. get top N to NMS
+    if pre_nms_topN > 0:
+        pre_nms_topN = tf.minimum(pre_nms_topN, tf.shape(decode_boxes)[0], name='avoid_unenough_boxes')
+        cls_prob, top_k_indices = tf.nn.top_k(cls_prob, k=pre_nms_topN)
+        decode_boxes = tf.gather(decode_boxes, top_k_indices)
+
+    # 4. NMS
+    keep = tf.image.non_max_suppression(
+        boxes=decode_boxes,
+        scores=cls_prob,
+        max_output_size=post_nms_topN,
+        iou_threshold=nms_thresh)
+
+    final_boxes = tf.gather(decode_boxes, keep)
+    final_probs = tf.gather(cls_prob, keep)
+
+    return final_boxes, final_probs
+
diff --git a/example-apps/PDD/pcb-defect-detection/libs/detection_oprations/proposal_target_layer.py b/example-apps/PDD/pcb-defect-detection/libs/detection_oprations/proposal_target_layer.py
new file mode 100755
index 0000000..bbfaaca
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/detection_oprations/proposal_target_layer.py
@@ -0,0 +1,145 @@
+# --------------------------------------------------------
+# Faster R-CNN
+# Copyright (c) 2015 Microsoft
+# Licensed under The MIT License [see LICENSE for details]
+# Written by Ross Girshick
+# --------------------------------------------------------
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from libs.configs import cfgs
+import numpy as np
+import numpy.random as npr
+
+from libs.box_utils import encode_and_decode
+from libs.box_utils.cython_utils.cython_bbox import bbox_overlaps
+
+
+def proposal_target_layer(rpn_rois, gt_boxes):
+    """
+    Assign object detection proposals to ground-truth targets. Produces proposal
+    classification labels and bounding-box regression targets.
+    """
+    # Proposal ROIs (x1, y1, x2, y2) coming from RPN
+    # gt_boxes (x1, y1, x2, y2, label)
+
+    if cfgs.ADD_GTBOXES_TO_TRAIN:
+        all_rois = np.vstack((rpn_rois, gt_boxes[:, :-1]))
+    else:
+        all_rois = rpn_rois
+
+    rois_per_image = np.inf if cfgs.FAST_RCNN_MINIBATCH_SIZE == -1 else cfgs.FAST_RCNN_MINIBATCH_SIZE
+
+    fg_rois_per_image = np.round(cfgs.FAST_RCNN_POSITIVE_RATE * rois_per_image)
+
+    # Sample rois with classification labels and bounding box regression
+    labels, rois, bbox_targets = _sample_rois(all_rois, gt_boxes, fg_rois_per_image,
+                                              rois_per_image, cfgs.CLASS_NUM+1)
+
+    rois = rois.reshape(-1, 4)
+    labels = labels.reshape(-1)
+    bbox_targets = bbox_targets.reshape(-1, (cfgs.CLASS_NUM+1) * 4)
+
+    return rois, labels, bbox_targets
+
+
+def _get_bbox_regression_labels(bbox_target_data, num_classes):
+    """Bounding-box regression targets (bbox_target_data) are stored in a
+    compact form N x (class, tx, ty, tw, th)
+
+    This function expands those targets into the 4-of-4*K representation used
+    by the network (i.e. only one class has non-zero targets).
+
+    Returns:
+        bbox_target (ndarray): N x 4K blob of regression targets
+    """
+
+    clss = bbox_target_data[:, 0]
+    bbox_targets = np.zeros((clss.size, 4 * num_classes), dtype=np.float32)
+    inds = np.where(clss > 0)[0]
+    for ind in inds:
+        cls = clss[ind]
+        start = int(4 * cls)
+        end = start + 4
+        bbox_targets[ind, start:end] = bbox_target_data[ind, 1:]
+
+    return bbox_targets
+
+
+def _compute_targets(ex_rois, gt_rois, labels):
+    """Compute bounding-box regression targets for an image.
+    that is : [label, tx, ty, tw, th]
+    """
+
+    assert ex_rois.shape[0] == gt_rois.shape[0]
+    assert ex_rois.shape[1] == 4
+    assert gt_rois.shape[1] == 4
+
+    targets = encode_and_decode.encode_boxes(unencode_boxes=gt_rois,
+                                             reference_boxes=ex_rois,
+                                             scale_factors=cfgs.ROI_SCALE_FACTORS)
+    # targets = encode_and_decode.encode_boxes(ex_rois=ex_rois,
+    #                                          gt_rois=gt_rois,
+    #                                          scale_factor=cfgs.ROI_SCALE_FACTORS)
+
+    return np.hstack(
+        (labels[:, np.newaxis], targets)).astype(np.float32, copy=False)
+
+
+def _sample_rois(all_rois, gt_boxes, fg_rois_per_image,
+                 rois_per_image, num_classes):
+    """Generate a random sample of RoIs comprising foreground and background
+    examples.
+
+    all_rois shape is [-1, 4]
+    gt_boxes shape is [-1, 5]. that is [x1, y1, x2, y2, label]
+    """
+    # overlaps: (rois x gt_boxes)
+    overlaps = bbox_overlaps(
+        np.ascontiguousarray(all_rois, dtype=np.float),
+        np.ascontiguousarray(gt_boxes[:, :-1], dtype=np.float))
+    gt_assignment = overlaps.argmax(axis=1)
+    max_overlaps = overlaps.max(axis=1)
+    labels = gt_boxes[gt_assignment, -1]
+
+    # Select foreground RoIs as those with >= FG_THRESH overlap
+    fg_inds = np.where(max_overlaps >= cfgs.FAST_RCNN_IOU_POSITIVE_THRESHOLD)[0]
+    # Guard against the case when an image has fewer than fg_rois_per_image
+    # Select background RoIs as those within [BG_THRESH_LO, BG_THRESH_HI)
+    bg_inds = np.where((max_overlaps < cfgs.FAST_RCNN_IOU_POSITIVE_THRESHOLD) &
+                       (max_overlaps >= cfgs.FAST_RCNN_IOU_NEGATIVE_THRESHOLD))[0]
+    # print("first fileter, fg_size: {} || bg_size: {}".format(fg_inds.shape, bg_inds.shape))
+    # Guard against the case when an image has fewer than fg_rois_per_image
+    # foreground RoIs
+    fg_rois_per_this_image = min(fg_rois_per_image, fg_inds.size)
+
+    # Sample foreground regions without replacement
+    if fg_inds.size > 0:
+        fg_inds = npr.choice(fg_inds, size=int(fg_rois_per_this_image), replace=False)
+    # Compute number of background RoIs to take from this image (guarding
+    # against there being fewer than desired)
+    bg_rois_per_this_image = rois_per_image - fg_rois_per_this_image
+    bg_rois_per_this_image = min(bg_rois_per_this_image, bg_inds.size)
+    # Sample background regions without replacement
+    if bg_inds.size > 0:
+        bg_inds = npr.choice(bg_inds, size=int(bg_rois_per_this_image), replace=False)
+
+    # print("second fileter, fg_size: {} || bg_size: {}".format(fg_inds.shape, bg_inds.shape))
+    # The indices that we're selecting (both fg and bg)
+    keep_inds = np.append(fg_inds, bg_inds)
+
+
+    # Select sampled values from various arrays:
+    labels = labels[keep_inds]
+
+    # Clamp labels for the background RoIs to 0
+    labels[int(fg_rois_per_this_image):] = 0
+    rois = all_rois[keep_inds]
+
+    bbox_target_data = _compute_targets(
+        rois, gt_boxes[gt_assignment[keep_inds], :-1], labels)
+
+    bbox_targets = \
+        _get_bbox_regression_labels(bbox_target_data, num_classes)
+
+    return labels, rois, bbox_targets
diff --git a/example-apps/PDD/pcb-defect-detection/libs/export_pbs/__init__.py b/example-apps/PDD/pcb-defect-detection/libs/export_pbs/__init__.py
new file mode 100755
index 0000000..e69de29
diff --git a/example-apps/PDD/pcb-defect-detection/libs/export_pbs/exportPb.py b/example-apps/PDD/pcb-defect-detection/libs/export_pbs/exportPb.py
new file mode 100755
index 0000000..8f4b217
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/export_pbs/exportPb.py
@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import, print_function, division
+
+import os, sys
+import tensorflow as tf
+import tensorflow.contrib.slim as slim
+from tensorflow.python.tools import freeze_graph
+
+sys.path.append('../../')
+from data.io.image_preprocess import short_side_resize_for_inference_data
+from libs.configs import cfgs
+from libs.networks import build_whole_network
+
+CKPT_PATH = '/home/yjr/PycharmProjects/Faster-RCNN_Tensorflow/output/trained_weights/FasterRCNN_20180517/voc_200000model.ckpt'
+OUT_DIR = '../../output/Pbs'
+PB_NAME = 'FasterRCNN_Res101_Pascal.pb'
+
+
+def build_detection_graph():
+    # 1. preprocess img
+    img_plac = tf.placeholder(dtype=tf.uint8, shape=[None, None, 3],
+                              name='input_img')  # is RGB. not GBR
+    raw_shape = tf.shape(img_plac)
+    raw_h, raw_w = tf.to_float(raw_shape[0]), tf.to_float(raw_shape[1])
+
+    img_batch = tf.cast(img_plac, tf.float32)
+    img_batch = short_side_resize_for_inference_data(img_tensor=img_batch,
+                                                     target_shortside_len=cfgs.IMG_SHORT_SIDE_LEN,
+                                                     length_limitation=cfgs.IMG_MAX_LENGTH)
+    img_batch = img_batch - tf.constant(cfgs.PIXEL_MEAN)
+    img_batch = tf.expand_dims(img_batch, axis=0)  # [1, None, None, 3]
+
+    det_net = build_whole_network.DetectionNetwork(base_network_name=cfgs.NET_NAME,
+                                                   is_training=False)
+
+    detected_boxes, detection_scores, detection_category = det_net.build_whole_detection_network(
+        input_img_batch=img_batch,
+        gtboxes_batch=None)
+
+    xmin, ymin, xmax, ymax = detected_boxes[:, 0], detected_boxes[:, 1], \
+                             detected_boxes[:, 2], detected_boxes[:, 3]
+
+    resized_shape = tf.shape(img_batch)
+    resized_h, resized_w = tf.to_float(resized_shape[1]), tf.to_float(resized_shape[2])
+
+    xmin = xmin * raw_w / resized_w
+    xmax = xmax * raw_w / resized_w
+
+    ymin = ymin * raw_h / resized_h
+    ymax = ymax * raw_h / resized_h
+
+    boxes = tf.transpose(tf.stack([xmin, ymin, xmax, ymax]))
+    dets = tf.concat([tf.reshape(detection_category, [-1, 1]),
+                     tf.reshape(detection_scores, [-1, 1]),
+                     boxes], axis=1, name='DetResults')
+
+    return dets
+
+
+def export_frozenPB():
+
+    tf.reset_default_graph()
+
+    dets = build_detection_graph()
+
+    saver = tf.train.Saver()
+
+    with tf.Session() as sess:
+        print("we have restred the weights from =====>>\n", CKPT_PATH)
+        saver.restore(sess, CKPT_PATH)
+
+        tf.train.write_graph(sess.graph_def, OUT_DIR, PB_NAME)
+        freeze_graph.freeze_graph(input_graph=os.path.join(OUT_DIR, PB_NAME),
+                                  input_saver='',
+                                  input_binary=False,
+                                  input_checkpoint=CKPT_PATH,
+                                  output_node_names="DetResults",
+                                  restore_op_name="save/restore_all",
+                                  filename_tensor_name='save/Const:0',
+                                  output_graph=os.path.join(OUT_DIR, PB_NAME.replace('.pb', '_Frozen.pb')),
+                                  clear_devices=False,
+                                  initializer_nodes='')
+
+if __name__ == '__main__':
+    os.environ["CUDA_VISIBLE_DEVICES"] = ''
+    export_frozenPB()
diff --git a/example-apps/PDD/pcb-defect-detection/libs/export_pbs/test_exportPb.py b/example-apps/PDD/pcb-defect-detection/libs/export_pbs/test_exportPb.py
new file mode 100755
index 0000000..ad78e42
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/export_pbs/test_exportPb.py
@@ -0,0 +1,81 @@
+# -*- coding:utf-8 -*-
+
+from __future__ import absolute_import
+from __future__ import print_function
+from __future__ import division
+
+import os, sys
+import tensorflow as tf
+import time
+import cv2
+import argparse
+import numpy as np
+sys.path.append("../")
+
+from data.io.image_preprocess import short_side_resize_for_inference_data
+from libs.configs import cfgs
+from libs.networks import build_whole_network
+from libs.box_utils import draw_box_in_img
+from help_utils import tools
+
+
+
+
+
+def load_graph(frozen_graph_file):
+
+    # we parse the graph_def file
+    with tf.gfile.GFile(frozen_graph_file, 'rb') as f:
+        graph_def = tf.GraphDef()
+        graph_def.ParseFromString(f.read())
+
+    # we load the graph_def in the default graph
+
+    with tf.Graph().as_default() as graph:
+        tf.import_graph_def(graph_def,
+                            input_map=None,
+                            return_elements=None,
+                            name="",
+                            op_dict=None,
+                            producer_op_list=None)
+    return graph
+
+
+def test(frozen_graph_path, test_dir):
+
+    graph = load_graph(frozen_graph_path)
+    print("we are testing ====>>>>", frozen_graph_path)
+
+    img = graph.get_tensor_by_name("input_img:0")
+    dets = graph.get_tensor_by_name("DetResults:0")
+
+    with tf.Session(graph=graph) as sess:
+        for img_path in os.listdir(test_dir):
+            a_img = cv2.imread(os.path.join(test_dir, img_path))[:, :, ::-1]
+            st = time.time()
+            dets_val = sess.run(dets, feed_dict={img: a_img})
+
+            show_indices = dets_val[:, 1] >= 0.5
+            dets_val = dets_val[show_indices]
+            final_detections = draw_box_in_img.draw_boxes_with_label_and_scores(a_img,
+                                                                                boxes=dets_val[:, 2:],
+                                                                                labels=dets_val[:, 0],
+                                                                                scores=dets_val[:, 1])
+            cv2.imwrite(img_path,
+                        final_detections[:, :, ::-1])
+            print ("%s cost time: %f" % (img_path, time.time() - st))
+
+if __name__ == '__main__':
+    test('/home/yjr/PycharmProjects/Faster-RCNN_Tensorflow/output/Pbs/FasterRCNN_Res101_Pascal_Frozen.pb',
+         '/home/yjr/PycharmProjects/Faster-RCNN_Tensorflow/tools/demos')
+
+
+
+
+
+
+
+
+
+
+
diff --git a/example-apps/PDD/pcb-defect-detection/libs/label_name_dict/__init__.py b/example-apps/PDD/pcb-defect-detection/libs/label_name_dict/__init__.py
new file mode 100755
index 0000000..e69de29
diff --git a/example-apps/PDD/pcb-defect-detection/libs/label_name_dict/__init__.pyc b/example-apps/PDD/pcb-defect-detection/libs/label_name_dict/__init__.pyc
new file mode 100755
index 0000000..64b67a2
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/libs/label_name_dict/__init__.pyc differ
diff --git a/example-apps/PDD/pcb-defect-detection/libs/label_name_dict/coco_dict.py b/example-apps/PDD/pcb-defect-detection/libs/label_name_dict/coco_dict.py
new file mode 100755
index 0000000..d4c190f
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/label_name_dict/coco_dict.py
@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import, print_function, division
+
+class_names = [
+    'back_ground', 'person', 'bicycle', 'car', 'motorcycle',
+    'airplane', 'bus', 'train', 'truck', 'boat', 'traffic light',
+    'fire hydrant', 'stop sign', 'parking meter', 'bench',
+    'bird', 'cat', 'dog', 'horse', 'sheep', 'cow', 'elephant',
+    'bear', 'zebra', 'giraffe', 'backpack', 'umbrella',
+    'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard',
+    'sports ball', 'kite', 'baseball bat', 'baseball glove',
+    'skateboard', 'surfboard', 'tennis racket', 'bottle',
+    'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl',
+    'banana', 'apple', 'sandwich', 'orange', 'broccoli',
+    'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair',
+    'couch', 'potted plant', 'bed', 'dining table', 'toilet',
+    'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone',
+    'microwave', 'oven', 'toaster', 'sink', 'refrigerator',
+    'book', 'clock', 'vase', 'scissors', 'teddy bear',
+    'hair drier', 'toothbrush']
+
+
+classes_originID = {
+    'person': 1, 'bicycle': 2, 'car': 3, 'motorcycle': 4,
+    'airplane': 5, 'bus': 6, 'train': 7, 'truck': 8, 'boat': 9,
+    'traffic light': 10, 'fire hydrant': 11, 'stop sign': 13,
+    'parking meter': 14, 'bench': 15, 'bird': 16, 'cat': 17,
+    'dog': 18, 'horse': 19, 'sheep': 20, 'cow': 21, 'elephant': 22,
+    'bear': 23, 'zebra': 24, 'giraffe': 25, 'backpack': 27,
+    'umbrella': 28, 'handbag': 31, 'tie': 32, 'suitcase': 33,
+    'frisbee': 34, 'skis': 35, 'snowboard': 36, 'sports ball': 37,
+    'kite': 38, 'baseball bat': 39, 'baseball glove': 40,
+    'skateboard': 41, 'surfboard': 42, 'tennis racket': 43,
+    'bottle': 44, 'wine glass': 46, 'cup': 47, 'fork': 48,
+    'knife': 49, 'spoon': 50, 'bowl': 51, 'banana': 52, 'apple': 53,
+    'sandwich': 54, 'orange': 55, 'broccoli': 56, 'carrot': 57,
+    'hot dog': 58, 'pizza': 59, 'donut': 60, 'cake': 61,
+    'chair': 62, 'couch': 63, 'potted plant': 64, 'bed': 65,
+    'dining table': 67, 'toilet': 70, 'tv': 72, 'laptop': 73,
+    'mouse': 74, 'remote': 75, 'keyboard': 76, 'cell phone': 77,
+    'microwave': 78, 'oven': 79, 'toaster': 80, 'sink': 81,
+    'refrigerator': 82, 'book': 84, 'clock': 85, 'vase': 86,
+    'scissors': 87, 'teddy bear': 88, 'hair drier': 89,
+    'toothbrush': 90}
+
+originID_classes = {item: key for key, item in classes_originID.items()}
+NAME_LABEL_MAP = dict(zip(class_names, range(len(class_names))))
+LABEL_NAME_MAP = dict(zip(range(len(class_names)), class_names))
+
+# print (originID_classes)
+
+
+
diff --git a/example-apps/PDD/pcb-defect-detection/libs/label_name_dict/label_dict.py b/example-apps/PDD/pcb-defect-detection/libs/label_name_dict/label_dict.py
new file mode 100755
index 0000000..dc5d504
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/label_name_dict/label_dict.py
@@ -0,0 +1,98 @@
+# -*- coding: utf-8 -*-
+from __future__ import division, print_function, absolute_import
+
+from libs.configs import cfgs
+
+if cfgs.DATASET_NAME == 'ship':
+    NAME_LABEL_MAP = {
+        'back_ground': 0,
+        'ship': 1
+    }
+elif cfgs.DATASET_NAME == 'aeroplane':
+    NAME_LABEL_MAP = {
+        'back_ground': 0,
+        'aeroplane': 1
+    }
+elif cfgs.DATASET_NAME == 'WIDER':
+    NAME_LABEL_MAP = {
+        'back_ground': 0,
+        'face': 1
+    }
+elif cfgs.DATASET_NAME == 'jyzdata':
+    NAME_LABEL_MAP = {
+        'back_ground': 0,
+        'classone': 1,
+        'boli': 2,
+        'dangeboli': 3,
+        'taoci': 4,
+        'taoci2': 4
+    }
+elif cfgs.DATASET_NAME == 'icdar':
+    NAME_LABEL_MAP = {
+        'back_ground': 0,
+        'text': 1
+    }
+elif cfgs.DATASET_NAME.startswith('DOTA'):
+    NAME_LABEL_MAP = {
+        'back_ground': 0,
+        'roundabout': 1,
+        'tennis-court': 2,
+        'swimming-pool': 3,
+        'storage-tank': 4,
+        'soccer-ball-field': 5,
+        'small-vehicle': 6,
+        'ship': 7,
+        'plane': 8,
+        'large-vehicle': 9,
+        'helicopter': 10,
+        'harbor': 11,
+        'ground-track-field': 12,
+        'bridge': 13,
+        'basketball-court': 14,
+        'baseball-diamond': 15
+    }
+elif cfgs.DATASET_NAME == 'pascal':
+    NAME_LABEL_MAP = {
+        'back_ground': 0,
+        'aeroplane': 1,
+        'bicycle': 2,
+        'bird': 3,
+        'boat': 4,
+        'bottle': 5,
+        'bus': 6,
+        'car': 7,
+        'cat': 8,
+        'chair': 9,
+        'cow': 10,
+        'diningtable': 11,
+        'dog': 12,
+        'horse': 13,
+        'motorbike': 14,
+        'person': 15,
+        'pottedplant': 16,
+        'sheep': 17,
+        'sofa': 18,
+        'train': 19,
+        'tvmonitor': 20
+    }
+elif cfgs.DATASET_NAME == 'pcb':
+    NAME_LABEL_MAP = {
+        'back_ground': 0,
+        'missing_hole': 1,
+        'mouse_bite': 2,
+        'open_circuit': 3,
+        'short': 4,
+        'spur': 5,
+        'spurious_copper': 6
+    }
+else:
+    assert 'please set label dict!'
+
+
+def get_label_name_map():
+    reverse_dict = {}
+    for name, label in NAME_LABEL_MAP.items():
+        reverse_dict[label] = name
+    return reverse_dict
+
+LABEl_NAME_MAP = get_label_name_map()
\ No newline at end of file
diff --git a/example-apps/PDD/pcb-defect-detection/libs/label_name_dict/label_dict.pyc b/example-apps/PDD/pcb-defect-detection/libs/label_name_dict/label_dict.pyc
new file mode 100755
index 0000000..38a1e54
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/libs/label_name_dict/label_dict.pyc differ
diff --git a/example-apps/PDD/pcb-defect-detection/libs/label_name_dict/remote_sensing_dict.py b/example-apps/PDD/pcb-defect-detection/libs/label_name_dict/remote_sensing_dict.py
new file mode 100755
index 0000000..5257bc9
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/label_name_dict/remote_sensing_dict.py
@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+
+NAME_LABEL_MAP = {
+    'back_ground': 0,
+    'building': 1
+}
+
+
+def get_label_name_map():
+    reverse_dict = {}
+    for name, label in NAME_LABEL_MAP.items():
+        reverse_dict[label] = name
+    return reverse_dict
+
+LABEl_NAME_MAP = get_label_name_map()
\ No newline at end of file
diff --git a/example-apps/PDD/pcb-defect-detection/libs/losses/__init__.py b/example-apps/PDD/pcb-defect-detection/libs/losses/__init__.py
new file mode 100755
index 0000000..e69de29
diff --git a/example-apps/PDD/pcb-defect-detection/libs/losses/losses.py b/example-apps/PDD/pcb-defect-detection/libs/losses/losses.py
new file mode 100755
index 0000000..32c9429
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/losses/losses.py
@@ -0,0 +1,135 @@
+# -*- coding: utf-8 -*-
+"""
+@author: jemmy li
+@contact: zengarden2009@gmail.com
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf
+
+
+def _smooth_l1_loss_base(bbox_pred, bbox_targets, sigma=1.0):
+    '''
+
+    :param bbox_pred: [-1, 4] in RPN. [-1, cls_num+1, 4] in Fast-rcnn
+    :param bbox_targets: shape is same as bbox_pred
+    :param sigma:
+    :return:
+    '''
+    sigma_2 = sigma**2
+
+    box_diff = bbox_pred - bbox_targets
+
+    abs_box_diff = tf.abs(box_diff)
+
+    smoothL1_sign = tf.stop_gradient(
+        tf.to_float(tf.less(abs_box_diff, 1. / sigma_2)))
+    loss_box = tf.pow(box_diff, 2) * (sigma_2 / 2.0) * smoothL1_sign \
+               + (abs_box_diff - (0.5 / sigma_2)) * (1.0 - smoothL1_sign)
+    return loss_box
+
+def smooth_l1_loss_rpn(bbox_pred, bbox_targets, label, sigma=1.0):
+    '''
+
+    :param bbox_pred: [-1, 4]
+    :param bbox_targets: [-1, 4]
+    :param label: [-1]
+    :param sigma:
+    :return:
+    '''
+    value = _smooth_l1_loss_base(bbox_pred, bbox_targets, sigma=sigma)
+    value = tf.reduce_sum(value, axis=1)  # to sum in axis 1
+    rpn_positive = tf.where(tf.greater(label, 0))
+
+    # rpn_select = tf.stop_gradient(rpn_select) # to avoid
+    selected_value = tf.gather(value, rpn_positive)
+    non_ignored_mask = tf.stop_gradient(
+        1.0 - tf.to_float(tf.equal(label, -1)))  # positve is 1.0 others is 0.0
+
+    bbox_loss = tf.reduce_sum(selected_value) / tf.maximum(1.0, tf.reduce_sum(non_ignored_mask))
+
+    return bbox_loss
+
+def smooth_l1_loss_rcnn(bbox_pred, bbox_targets, label, num_classes, sigma=1.0):
+    '''
+
+    :param bbox_pred: [-1, (cfgs.CLS_NUM +1) * 4]
+    :param bbox_targets:[-1, (cfgs.CLS_NUM +1) * 4]
+    :param label:[-1]
+    :param num_classes:
+    :param sigma:
+    :return:
+    '''
+
+    outside_mask = tf.stop_gradient(tf.to_float(tf.greater(label, 0)))
+
+    bbox_pred = tf.reshape(bbox_pred, [-1, num_classes, 4])
+    bbox_targets = tf.reshape(bbox_targets, [-1, num_classes, 4])
+
+    value = _smooth_l1_loss_base(bbox_pred,
+                                 bbox_targets,
+                                 sigma=sigma)
+    value = tf.reduce_sum(value, 2)
+    value = tf.reshape(value, [-1, num_classes])
+
+    inside_mask = tf.one_hot(tf.reshape(label, [-1, 1]),
+                             depth=num_classes, axis=1)
+
+    inside_mask = tf.stop_gradient(
+        tf.to_float(tf.reshape(inside_mask, [-1, num_classes])))
+
+    normalizer = tf.to_float(tf.shape(bbox_pred)[0])
+    bbox_loss = tf.reduce_sum(
+        tf.reduce_sum(value * inside_mask, 1)*outside_mask) / normalizer
+
+    return bbox_loss
+
+def sum_ohem_loss(cls_score, label, bbox_pred, bbox_targets,
+                  num_classes, num_ohem_samples=256, sigma=1.0):
+
+    '''
+    :param cls_score: [-1, cls_num+1]
+    :param label: [-1]
+    :param bbox_pred: [-1, 4*(cls_num+1)]
+    :param bbox_targets: [-1, 4*(cls_num+1)]
+    :param num_ohem_samples: 256 by default
+    :param num_classes: cls_num+1
+    :param sigma:
+    :return:
+    '''
+    cls_loss = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=cls_score, labels=label)  # [-1, ]
+    # cls_loss = tf.Print(cls_loss, [tf.shape(cls_loss)], summarize=10, message='CLS losss shape ****')
+
+    outside_mask = tf.stop_gradient(tf.to_float(tf.greater(label, 0)))
+    bbox_pred = tf.reshape(bbox_pred, [-1, num_classes, 4])
+    bbox_targets = tf.reshape(bbox_targets, [-1, num_classes, 4])
+
+    value = _smooth_l1_loss_base(bbox_pred,
+                                 bbox_targets,
+                                 sigma=sigma)
+    value = tf.reduce_sum(value, 2)
+    value = tf.reshape(value, [-1, num_classes])
+
+    inside_mask = tf.one_hot(tf.reshape(label, [-1, 1]),
+                             depth=num_classes, axis=1)
+
+    inside_mask = tf.stop_gradient(
+        tf.to_float(tf.reshape(inside_mask, [-1, num_classes])))
+    loc_loss = tf.reduce_sum(value * inside_mask, 1)*outside_mask
+    # loc_loss = tf.Print(loc_loss, [tf.shape(loc_loss)], summarize=10, message='loc_loss shape***')
+
+    sum_loss = cls_loss + loc_loss
+
+    num_ohem_samples = tf.stop_gradient(tf.minimum(num_ohem_samples, tf.shape(sum_loss)[0]))
+    _, top_k_indices = tf.nn.top_k(sum_loss, k=num_ohem_samples)
+
+    cls_loss_ohem = tf.gather(cls_loss, top_k_indices)
+    cls_loss_ohem = tf.reduce_mean(cls_loss_ohem)
+
+    loc_loss_ohem = tf.gather(loc_loss, top_k_indices)
+    normalizer = tf.to_float(num_ohem_samples)
+    loc_loss_ohem = tf.reduce_sum(loc_loss_ohem) / normalizer
+
+    return cls_loss_ohem, loc_loss_ohem
\ No newline at end of file
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/__init__.py b/example-apps/PDD/pcb-defect-detection/libs/networks/__init__.py
new file mode 100755
index 0000000..e69de29
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/build_whole_network.py b/example-apps/PDD/pcb-defect-detection/libs/networks/build_whole_network.py
new file mode 100755
index 0000000..e5d4c17
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/build_whole_network.py
@@ -0,0 +1,636 @@
+# -*-coding: utf-8 -*-
+
+from __future__ import absolute_import, division, print_function
+
+import os
+import tensorflow as tf
+import tensorflow.contrib.slim as slim
+import numpy as np
+
+from libs.networks import resnet
+from libs.networks import mobilenet_v2
+from libs.box_utils import encode_and_decode
+from libs.box_utils import boxes_utils
+from libs.box_utils import anchor_utils
+from libs.configs import cfgs
+from libs.losses import losses
+from libs.box_utils import show_box_in_tensor
+from libs.detection_oprations.proposal_opr import postprocess_rpn_proposals
+from libs.detection_oprations.anchor_target_layer_without_boxweight import anchor_target_layer
+from libs.detection_oprations.proposal_target_layer import proposal_target_layer
+
+
+class DetectionNetwork(object):
+
+    def __init__(self, base_network_name, is_training):
+
+        self.base_network_name = base_network_name
+        self.is_training = is_training
+        self.num_anchors_per_location = len(cfgs.ANCHOR_SCALES) * len(cfgs.ANCHOR_RATIOS)
+
+    def build_base_network(self, input_img_batch):
+
+        if self.base_network_name.startswith('resnet_v1'):
+            return resnet.resnet_base(input_img_batch, scope_name=self.base_network_name, is_training=self.is_training)
+
+        elif self.base_network_name.startswith('MobilenetV2'):
+            return mobilenet_v2.mobilenetv2_base(input_img_batch, is_training=self.is_training)
+
+        else:
+            raise ValueError('Sry, we only support resnet or mobilenet_v2')
+
+    def postprocess_fastrcnn(self, rois, bbox_ppred, scores, img_shape):
+        '''
+
+        :param rois:[-1, 4]
+        :param bbox_ppred: [-1, (cfgs.Class_num+1) * 4]
+        :param scores: [-1, cfgs.Class_num + 1]
+        :return:
+        '''
+
+        with tf.name_scope('postprocess_fastrcnn'):
+            rois = tf.stop_gradient(rois)
+            scores = tf.stop_gradient(scores)
+            bbox_ppred = tf.reshape(bbox_ppred, [-1, cfgs.CLASS_NUM + 1, 4])
+            bbox_ppred = tf.stop_gradient(bbox_ppred)
+
+            bbox_pred_list = tf.unstack(bbox_ppred, axis=1)
+            score_list = tf.unstack(scores, axis=1)
+
+            allclasses_boxes = []
+            allclasses_scores = []
+            categories = []
+            for i in range(1, cfgs.CLASS_NUM+1):
+
+                # 1. decode boxes in each class
+                tmp_encoded_box = bbox_pred_list[i]
+                tmp_score = score_list[i]
+                tmp_decoded_boxes = encode_and_decode.decode_boxes(encoded_boxes=tmp_encoded_box,
+                                                                   reference_boxes=rois,
+                                                                   scale_factors=cfgs.ROI_SCALE_FACTORS)
+                # tmp_decoded_boxes = encode_and_decode.decode_boxes(boxes=rois,
+                #                                                    deltas=tmp_encoded_box,
+                #                                                    scale_factor=cfgs.ROI_SCALE_FACTORS)
+
+                # 2. clip to img boundaries
+                tmp_decoded_boxes = boxes_utils.clip_boxes_to_img_boundaries(decode_boxes=tmp_decoded_boxes,
+                                                                             img_shape=img_shape)
+
+                # 3. NMS
+                keep = tf.image.non_max_suppression(
+                    boxes=tmp_decoded_boxes,
+                    scores=tmp_score,
+                    max_output_size=cfgs.FAST_RCNN_NMS_MAX_BOXES_PER_CLASS,
+                    iou_threshold=cfgs.FAST_RCNN_NMS_IOU_THRESHOLD)
+
+                perclass_boxes = tf.gather(tmp_decoded_boxes, keep)
+                perclass_scores = tf.gather(tmp_score, keep)
+
+                allclasses_boxes.append(perclass_boxes)
+                allclasses_scores.append(perclass_scores)
+                categories.append(tf.ones_like(perclass_scores) * i)
+
+            final_boxes = tf.concat(allclasses_boxes, axis=0)
+            final_scores = tf.concat(allclasses_scores, axis=0)
+            final_category = tf.concat(categories, axis=0)
+
+            if self.is_training:
+                '''
+                in training. We should show the detecitons in the tensorboard. So we add this.
+                '''
+                kept_indices = tf.reshape(tf.where(tf.greater_equal(final_scores, cfgs.SHOW_SCORE_THRSHOLD)), [-1])
+
+                final_boxes = tf.gather(final_boxes, kept_indices)
+                final_scores = tf.gather(final_scores, kept_indices)
+                final_category = tf.gather(final_category, kept_indices)
+
+        return final_boxes, final_scores, final_category
+
+    def roi_pooling(self, feature_maps, rois, img_shape, scope):
+        '''
+        Here use roi warping as roi_pooling
+
+        :param featuremaps_dict: feature map to crop
+        :param rois: shape is [-1, 4]. [x1, y1, x2, y2]
+        :return:
+        '''
+
+        with tf.variable_scope('ROI_Warping_'+scope):
+            img_h, img_w = tf.cast(img_shape[1], tf.float32), tf.cast(img_shape[2], tf.float32)
+            N = tf.shape(rois)[0]
+            x1, y1, x2, y2 = tf.unstack(rois, axis=1)
+
+            normalized_x1 = x1 / img_w
+            normalized_x2 = x2 / img_w
+            normalized_y1 = y1 / img_h
+            normalized_y2 = y2 / img_h
+
+            normalized_rois = tf.transpose(
+                tf.stack([normalized_y1, normalized_x1, normalized_y2, normalized_x2]), name='get_normalized_rois')
+
+            normalized_rois = tf.stop_gradient(normalized_rois)
+
+            cropped_roi_features = tf.image.crop_and_resize(feature_maps, normalized_rois,
+                                                            box_ind=tf.zeros(shape=[N, ],
+                                                                             dtype=tf.int32),
+                                                            crop_size=[cfgs.ROI_SIZE, cfgs.ROI_SIZE],
+                                                            name='CROP_AND_RESIZE'
+                                                            )
+            roi_features = slim.max_pool2d(cropped_roi_features,
+                                           [cfgs.ROI_POOL_KERNEL_SIZE, cfgs.ROI_POOL_KERNEL_SIZE],
+                                           stride=cfgs.ROI_POOL_KERNEL_SIZE)
+
+        return roi_features
+
+    def build_fastrcnn(self, P_list, rois_list, img_shape):
+
+        with tf.variable_scope('Fast-RCNN'):
+            # 5. ROI Pooling
+            with tf.variable_scope('rois_pooling'):
+                pooled_features_list = []
+                for level_name, p, rois in zip(cfgs.LEVLES, P_list, rois_list):  # exclude P6_rois
+                    # p = tf.Print(p, [tf.shape(p)], summarize=10, message=level_name+'SHPAE***')
+                    pooled_features = self.roi_pooling(feature_maps=p, rois=rois, img_shape=img_shape,
+                                                       scope=level_name)
+                    pooled_features_list.append(pooled_features)
+
+                pooled_features = tf.concat(pooled_features_list, axis=0) # [minibatch_size, H, W, C]
+
+            # 6. inferecne rois in Fast-RCNN to obtain fc_flatten features
+            if self.base_network_name.startswith('resnet'):
+                fc_flatten = resnet.restnet_head(inputs=pooled_features,
+                                                 is_training=self.is_training,
+                                                 scope_name=self.base_network_name)
+            elif self.base_network_name.startswith('Mobile'):
+                fc_flatten = mobilenet_v2.mobilenetv2_head(inputs=pooled_features,
+                                                           is_training=self.is_training)
+            else:
+                raise NotImplementedError('only support resnet and mobilenet')
+
+            # 7. cls and reg in Fast-RCNN
+            with slim.arg_scope([slim.fully_connected], weights_regularizer=slim.l2_regularizer(cfgs.WEIGHT_DECAY)):
+
+                cls_score = slim.fully_connected(fc_flatten,
+                                                 num_outputs=cfgs.CLASS_NUM+1,
+                                                 weights_initializer=cfgs.INITIALIZER,
+                                                 activation_fn=None, trainable=self.is_training,
+                                                 scope='cls_fc')
+
+                bbox_pred = slim.fully_connected(fc_flatten,
+                                                 num_outputs=(cfgs.CLASS_NUM+1)*4,
+                                                 weights_initializer=cfgs.BBOX_INITIALIZER,
+                                                 activation_fn=None, trainable=self.is_training,
+                                                 scope='reg_fc')
+                # for convient. It also produce (cls_num +1) bboxes
+
+                cls_score = tf.reshape(cls_score, [-1, cfgs.CLASS_NUM+1])
+                bbox_pred = tf.reshape(bbox_pred, [-1, 4*(cfgs.CLASS_NUM+1)])
+
+                return bbox_pred, cls_score
+
+    def assign_levels(self, all_rois, labels=None, bbox_targets=None):
+        '''
+
+        :param all_rois:
+        :param labels:
+        :param bbox_targets:
+        :return:
+        '''
+        with tf.name_scope('assign_levels'):
+            # all_rois = tf.Print(all_rois, [tf.shape(all_rois)], summarize=10, message='ALL_ROIS_SHAPE*****')
+            xmin, ymin, xmax, ymax = tf.unstack(all_rois, axis=1)
+
+            h = tf.maximum(0., ymax - ymin)
+            w = tf.maximum(0., xmax - xmin)
+
+            levels = tf.floor(4. + tf.log(tf.sqrt(w * h + 1e-8) / 224.0) / tf.log(2.))  # 4 + log_2(***)
+            # use floor instead of round
+
+            min_level = int(cfgs.LEVLES[0][-1])
+            max_level = min(5, int(cfgs.LEVLES[-1][-1]))
+            levels = tf.maximum(levels, tf.ones_like(levels) * min_level)  # level minimum is 2
+            levels = tf.minimum(levels, tf.ones_like(levels) * max_level)  # level maximum is 5
+
+            levels = tf.stop_gradient(tf.reshape(levels, [-1]))
+
+            def get_rois(levels, level_i, rois, labels, bbox_targets):
+
+                level_i_indices = tf.reshape(tf.where(tf.equal(levels, level_i)), [-1])
+                # level_i_indices = tf.Print(level_i_indices, [tf.shape(tf.where(tf.equal(levels, level_i)))[0]], message="SHAPE%d***"%level_i,
+                #                            summarize=10)
+                tf.summary.scalar('LEVEL/LEVEL_%d_rois_NUM'%level_i, tf.shape(level_i_indices)[0])
+                level_i_rois = tf.gather(rois, level_i_indices)
+
+                if self.is_training:
+                    # If you use low version tensorflow, you may uncomment these code.
+                    level_i_rois = tf.stop_gradient(tf.concat([level_i_rois, [[0, 0, 0., 0.]]], axis=0))
+                    # # to avoid the num of level i rois is 0.0, which will broken the BP in tf
+                    #
+                    level_i_labels = tf.gather(labels, level_i_indices)
+                    level_i_labels = tf.stop_gradient(tf.concat([level_i_labels, [0]], axis=0))
+                    
+                    level_i_targets = tf.gather(bbox_targets, level_i_indices)
+                    level_i_targets = tf.stop_gradient(tf.concat([level_i_targets,
+                                                                    tf.zeros(shape=(1, 4*(cfgs.CLASS_NUM+1)), dtype=tf.float32)],
+                                                                    axis=0))
+                    #level_i_rois = tf.stop_gradient(level_i_rois)
+                    #level_i_labels = tf.gather(labels, level_i_indices)
+
+                    #level_i_targets = tf.gather(bbox_targets, level_i_indices)
+
+                    return level_i_rois, level_i_labels, level_i_targets
+                else:
+                    return level_i_rois, None, None
+
+            rois_list = []
+            labels_list = []
+            targets_list = []
+            for i in range(min_level, max_level+1):
+                P_i_rois, P_i_labels, P_i_targets = get_rois(levels, level_i=i, rois=all_rois,
+                                                             labels=labels,
+                                                             bbox_targets=bbox_targets)
+                rois_list.append(P_i_rois)
+                labels_list.append(P_i_labels)
+                targets_list.append(P_i_targets)
+
+            if self.is_training:
+                all_labels = tf.concat(labels_list, axis=0)
+                all_targets = tf.concat(targets_list, axis=0)
+                return rois_list, all_labels, all_targets
+            else:
+                return rois_list  # [P2_rois, P3_rois, P4_rois, P5_rois] Note: P6 do not assign rois
+
+    def add_anchor_img_smry(self, img, anchors, labels):
+
+        positive_anchor_indices = tf.reshape(tf.where(tf.greater_equal(labels, 1)), [-1])
+        negative_anchor_indices = tf.reshape(tf.where(tf.equal(labels, 0)), [-1])
+
+        positive_anchor = tf.gather(anchors, positive_anchor_indices)
+        negative_anchor = tf.gather(anchors, negative_anchor_indices)
+
+        pos_in_img = show_box_in_tensor.only_draw_boxes(img_batch=img,
+                                                        boxes=positive_anchor)
+        neg_in_img = show_box_in_tensor.only_draw_boxes(img_batch=img,
+                                                        boxes=negative_anchor)
+
+        tf.summary.image('positive_anchor', pos_in_img)
+        tf.summary.image('negative_anchors', neg_in_img)
+
+    def add_roi_batch_img_smry(self, img, rois, labels):
+        positive_roi_indices = tf.reshape(tf.where(tf.greater_equal(labels, 1)), [-1])
+
+        negative_roi_indices = tf.reshape(tf.where(tf.equal(labels, 0)), [-1])
+
+        pos_roi = tf.gather(rois, positive_roi_indices)
+        neg_roi = tf.gather(rois, negative_roi_indices)
+
+
+        pos_in_img = show_box_in_tensor.only_draw_boxes(img_batch=img,
+                                                               boxes=pos_roi)
+        neg_in_img = show_box_in_tensor.only_draw_boxes(img_batch=img,
+                                                               boxes=neg_roi)
+        tf.summary.image('pos_rois', pos_in_img)
+        tf.summary.image('neg_rois', neg_in_img)
+
+    def build_loss(self, rpn_box_pred, rpn_bbox_targets, rpn_cls_score, rpn_labels,
+                   bbox_pred, bbox_targets, cls_score, labels):
+        '''
+
+        :param rpn_box_pred: [-1, 4]
+        :param rpn_bbox_targets: [-1, 4]
+        :param rpn_cls_score: [-1]
+        :param rpn_labels: [-1]
+        :param bbox_pred: [-1, 4*(cls_num+1)]
+        :param bbox_targets: [-1, 4*(cls_num+1)]
+        :param cls_score: [-1, cls_num+1]
+        :param labels: [-1]
+        :return:
+        '''
+        with tf.variable_scope('build_loss') as sc:
+            with tf.variable_scope('rpn_loss'):
+
+                rpn_bbox_loss = losses.smooth_l1_loss_rpn(bbox_pred=rpn_box_pred,
+                                                          bbox_targets=rpn_bbox_targets,
+                                                          label=rpn_labels,
+                                                          sigma=cfgs.RPN_SIGMA)
+                # rpn_cls_loss:
+                # rpn_cls_score = tf.reshape(rpn_cls_score, [-1, 2])
+                # rpn_labels = tf.reshape(rpn_labels, [-1])
+                # ensure rpn_labels shape is [-1]
+                rpn_select = tf.reshape(tf.where(tf.not_equal(rpn_labels, -1)), [-1])
+                rpn_cls_score = tf.reshape(tf.gather(rpn_cls_score, rpn_select), [-1, 2])
+                rpn_labels = tf.reshape(tf.gather(rpn_labels, rpn_select), [-1])
+                rpn_cls_loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=rpn_cls_score,
+                                                                                             labels=rpn_labels))
+
+                rpn_cls_loss = rpn_cls_loss * cfgs.RPN_CLASSIFICATION_LOSS_WEIGHT
+                rpn_bbox_loss = rpn_bbox_loss * cfgs.RPN_LOCATION_LOSS_WEIGHT
+
+            with tf.variable_scope('FastRCNN_loss'):
+                if not cfgs.FAST_RCNN_MINIBATCH_SIZE == -1:
+                    bbox_loss = losses.smooth_l1_loss_rcnn(bbox_pred=bbox_pred,
+                                                           bbox_targets=bbox_targets,
+                                                           label=labels,
+                                                           num_classes=cfgs.CLASS_NUM + 1,
+                                                           sigma=cfgs.FASTRCNN_SIGMA)
+
+                    # cls_score = tf.reshape(cls_score, [-1, cfgs.CLASS_NUM + 1])
+                    # labels = tf.reshape(labels, [-1])
+                    cls_loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(
+                        logits=cls_score,
+                        labels=labels))  # beacause already sample before
+                else:
+                    ''' 
+                    applying OHEM here
+                    '''
+                    print(20 * "@@")
+                    print("@@" + 10 * " " + "TRAIN WITH OHEM ...")
+                    print(20 * "@@")
+                    cls_loss, bbox_loss = losses.sum_ohem_loss(
+                        cls_score=cls_score,
+                        label=labels,
+                        bbox_targets=bbox_targets,
+                        bbox_pred=bbox_pred,
+                        num_ohem_samples=128,
+                        num_classes=cfgs.CLASS_NUM + 1)
+                cls_loss = cls_loss * cfgs.FAST_RCNN_CLASSIFICATION_LOSS_WEIGHT
+                bbox_loss = bbox_loss * cfgs.FAST_RCNN_LOCATION_LOSS_WEIGHT
+            loss_dict = {
+                'rpn_cls_loss': rpn_cls_loss,
+                'rpn_loc_loss': rpn_bbox_loss,
+                'fastrcnn_cls_loss': cls_loss,
+                'fastrcnn_loc_loss': bbox_loss
+            }
+        return loss_dict
+
+    def build_whole_detection_network(self, input_img_batch, gtboxes_batch):
+
+        if self.is_training:
+            # ensure shape is [M, 5]
+            gtboxes_batch = tf.reshape(gtboxes_batch, [-1, 5])
+            gtboxes_batch = tf.cast(gtboxes_batch, tf.float32)
+
+        img_shape = tf.shape(input_img_batch)
+
+        # 1. build base network
+        P_list = self.build_base_network(input_img_batch)  # [P2, P3, P4, P5, P6]
+
+        # 2. build rpn
+        with tf.variable_scope('build_rpn',
+                               regularizer=slim.l2_regularizer(cfgs.WEIGHT_DECAY)):
+
+            fpn_cls_score =[]
+            fpn_box_pred = []
+            for level_name, p in zip(cfgs.LEVLES, P_list):
+                if cfgs.SHARE_HEADS:
+                    reuse_flag = None if level_name==cfgs.LEVLES[0] else True
+                    scope_list=['rpn_conv/3x3', 'rpn_cls_score', 'rpn_bbox_pred']
+                else:
+                    reuse_flag = None
+                    scope_list= ['rpn_conv/3x3_%s' % level_name, 'rpn_cls_score_%s' % level_name, 'rpn_bbox_pred_%s' % level_name]
+                rpn_conv3x3 = slim.conv2d(
+                    p, 512, [3, 3],
+                    trainable=self.is_training, weights_initializer=cfgs.INITIALIZER, padding="SAME",
+                    activation_fn=tf.nn.relu,
+                    scope=scope_list[0],
+                    reuse=reuse_flag)
+                rpn_cls_score = slim.conv2d(rpn_conv3x3, self.num_anchors_per_location*2, [1, 1], stride=1,
+                                            trainable=self.is_training, weights_initializer=cfgs.INITIALIZER,
+                                            activation_fn=None, padding="VALID",
+                                            scope=scope_list[1],
+                                            reuse=reuse_flag)
+                rpn_box_pred = slim.conv2d(rpn_conv3x3, self.num_anchors_per_location*4, [1, 1], stride=1,
+                                           trainable=self.is_training, weights_initializer=cfgs.BBOX_INITIALIZER,
+                                           activation_fn=None, padding="VALID",
+                                           scope=scope_list[2],
+                                           reuse=reuse_flag)
+                rpn_box_pred = tf.reshape(rpn_box_pred, [-1, 4])
+                rpn_cls_score = tf.reshape(rpn_cls_score, [-1, 2])
+
+                fpn_cls_score.append(rpn_cls_score)
+                fpn_box_pred.append(rpn_box_pred)
+
+            fpn_cls_score = tf.concat(fpn_cls_score, axis=0, name='fpn_cls_score')
+            fpn_box_pred = tf.concat(fpn_box_pred, axis=0, name='fpn_box_pred')
+            fpn_cls_prob = slim.softmax(fpn_cls_score, scope='fpn_cls_prob')
+
+        # 3. generate_anchors
+        all_anchors = []
+        for i in range(len(cfgs.LEVLES)):
+            level_name, p = cfgs.LEVLES[i], P_list[i]
+
+            p_h, p_w = tf.shape(p)[1], tf.shape(p)[2]
+            featuremap_height = tf.cast(p_h, tf.float32)
+            featuremap_width = tf.cast(p_w, tf.float32)
+            anchors = anchor_utils.make_anchors(base_anchor_size=cfgs.BASE_ANCHOR_SIZE_LIST[i],
+                                                anchor_scales=cfgs.ANCHOR_SCALES,
+                                                anchor_ratios=cfgs.ANCHOR_RATIOS,
+                                                featuremap_height=featuremap_height,
+                                                featuremap_width=featuremap_width,
+                                                stride=cfgs.ANCHOR_STRIDE_LIST[i],
+                                                name="make_anchors_for%s" % level_name)
+            all_anchors.append(anchors)
+        all_anchors = tf.concat(all_anchors, axis=0, name='all_anchors_of_FPN')
+
+        # 4. postprocess rpn proposals. such as: decode, clip, NMS
+        with tf.variable_scope('postprocess_FPN'):
+            rois, roi_scores = postprocess_rpn_proposals(rpn_bbox_pred=fpn_box_pred,
+                                                         rpn_cls_prob=fpn_cls_prob,
+                                                         img_shape=img_shape,
+                                                         anchors=all_anchors,
+                                                         is_training=self.is_training)
+            # rois shape [-1, 4]
+            # +++++++++++++++++++++++++++++++++++++add img smry+++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+            if self.is_training:
+                score_gre_05 = tf.reshape(tf.where(tf.greater_equal(roi_scores, 0.5)), [-1])
+                score_gre_05_rois = tf.gather(rois, score_gre_05)
+                score_gre_05_score = tf.gather(roi_scores, score_gre_05)
+                score_gre_05_in_img = show_box_in_tensor.draw_boxes_with_scores(img_batch=input_img_batch,
+                                                                                boxes=score_gre_05_rois,
+                                                                                scores=score_gre_05_score)
+                tf.summary.image('score_greater_05_rois', score_gre_05_in_img)
+            # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+        if self.is_training:
+            with tf.variable_scope('sample_anchors_minibatch'):
+                fpn_labels, fpn_bbox_targets = \
+                    tf.py_func(
+                        anchor_target_layer,
+                        [gtboxes_batch, img_shape, all_anchors],
+                        [tf.float32, tf.float32])
+                fpn_bbox_targets = tf.reshape(fpn_bbox_targets, [-1, 4])
+                fpn_labels = tf.to_int32(fpn_labels, name="to_int32")
+                fpn_labels = tf.reshape(fpn_labels, [-1])
+                self.add_anchor_img_smry(input_img_batch, all_anchors, fpn_labels)
+
+            # --------------------------------------add smry-----------------------------------------------------------
+
+            fpn_cls_category = tf.argmax(fpn_cls_prob, axis=1)
+            kept_rpppn = tf.reshape(tf.where(tf.not_equal(fpn_labels, -1)), [-1])
+            fpn_cls_category = tf.gather(fpn_cls_category, kept_rpppn)
+            acc = tf.reduce_mean(tf.to_float(tf.equal(fpn_cls_category,
+                                                      tf.to_int64(tf.gather(fpn_labels, kept_rpppn)))))
+            tf.summary.scalar('ACC/fpn_accuracy', acc)
+
+            with tf.control_dependencies([fpn_labels]):
+                with tf.variable_scope('sample_RCNN_minibatch'):
+                    rois, labels, bbox_targets = \
+                    tf.py_func(proposal_target_layer,
+                               [rois, gtboxes_batch],
+                               [tf.float32, tf.float32, tf.float32])
+                    rois = tf.reshape(rois, [-1, 4])
+                    labels = tf.to_int32(labels)
+                    labels = tf.reshape(labels, [-1])
+                    bbox_targets = tf.reshape(bbox_targets, [-1, 4*(cfgs.CLASS_NUM+1)])
+                    self.add_roi_batch_img_smry(input_img_batch, rois, labels)
+        if self.is_training:
+            rois_list, labels, bbox_targets = self.assign_levels(all_rois=rois,
+                                                                 labels=labels,
+                                                                 bbox_targets=bbox_targets)
+        else:
+            rois_list = self.assign_levels(all_rois=rois)  # rois_list: [P2_rois, P3_rois, P4_rois, P5_rois]
+
+        # -------------------------------------------------------------------------------------------------------------#
+        #                                            Fast-RCNN                                                         #
+        # -------------------------------------------------------------------------------------------------------------#
+
+        # 5. build Fast-RCNN
+        # rois = tf.Print(rois, [tf.shape(rois)], 'rois shape', summarize=10)
+        bbox_pred, cls_score = self.build_fastrcnn(P_list=P_list, rois_list=rois_list,
+                                                   img_shape=img_shape)
+        # bbox_pred shape: [-1, 4*(cls_num+1)].
+        # cls_score shapeï¼?[-1, cls_num+1]
+
+        cls_prob = slim.softmax(cls_score, 'cls_prob')
+
+
+        # ----------------------------------------------add smry-------------------------------------------------------
+        if self.is_training:
+            cls_category = tf.argmax(cls_prob, axis=1)
+            fast_acc = tf.reduce_mean(tf.to_float(tf.equal(cls_category, tf.to_int64(labels))))
+            tf.summary.scalar('ACC/fast_acc', fast_acc)
+
+        rois = tf.concat(rois_list, axis=0, name='concat_rois')
+        #  6. postprocess_fastrcnn
+        if not self.is_training:
+            return self.postprocess_fastrcnn(rois=rois, bbox_ppred=bbox_pred, scores=cls_prob, img_shape=img_shape)
+        else:
+            '''
+            when trian. We need build Loss
+            '''
+            loss_dict = self.build_loss(rpn_box_pred=fpn_box_pred,
+                                        rpn_bbox_targets=fpn_bbox_targets,
+                                        rpn_cls_score=fpn_cls_score,
+                                        rpn_labels=fpn_labels,
+                                        bbox_pred=bbox_pred,
+                                        bbox_targets=bbox_targets,
+                                        cls_score=cls_score,
+                                        labels=labels)
+
+            final_bbox, final_scores, final_category = self.postprocess_fastrcnn(rois=rois,
+                                                                                 bbox_ppred=bbox_pred,
+                                                                                 scores=cls_prob,
+                                                                                 img_shape=img_shape)
+            return final_bbox, final_scores, final_category, loss_dict
+
+    def get_restorer(self):
+        checkpoint_path = tf.train.latest_checkpoint(os.path.join(cfgs.TRAINED_CKPT, cfgs.VERSION))
+
+        if checkpoint_path != None:
+            restorer = tf.train.Saver()
+            print("model restore from :", checkpoint_path)
+        else:
+            checkpoint_path = cfgs.PRETRAINED_CKPT
+            print("model restore from pretrained mode, path is :", checkpoint_path)
+
+            model_variables = slim.get_model_variables()
+            # for var in model_variables:
+            #     print(var.name)
+            # print(20*"__++__++__")
+
+            def name_in_ckpt_rpn(var):
+                return var.op.name
+
+            def name_in_ckpt_fastrcnn_head(var):
+                '''
+                Fast-RCNN/resnet_v1_50/block4 -->resnet_v1_50/block4
+                Fast-RCNN/MobilenetV2/** -- > MobilenetV2 **
+                :param var:
+                :return:
+                '''
+                return '/'.join(var.op.name.split('/')[1:])
+            nameInCkpt_Var_dict = {}
+            for var in model_variables:
+                if var.name.startswith(self.base_network_name):
+                    var_name_in_ckpt = name_in_ckpt_rpn(var)
+                    nameInCkpt_Var_dict[var_name_in_ckpt] = var
+            restore_variables = nameInCkpt_Var_dict
+            for key, item in restore_variables.items():
+                print("var_in_graph: ", item.name)
+                print("var_in_ckpt: ", key)
+                print(20*"___")
+            restorer = tf.train.Saver(restore_variables)
+            print(20 * "****")
+            print("restore from pretrained_weighs in IMAGE_NET")
+        return restorer, checkpoint_path
+
+    def get_gradients(self, optimizer, loss):
+        '''
+
+        :param optimizer:
+        :param loss:
+        :return:
+
+        return vars and grads that not be fixed
+        '''
+
+        # if cfgs.FIXED_BLOCKS > 0:
+        #     trainable_vars = tf.trainable_variables()
+        #     # trained_vars = slim.get_trainable_variables()
+        #     start_names = [cfgs.NET_NAME + '/block%d'%i for i in range(1, cfgs.FIXED_BLOCKS+1)] + \
+        #                   [cfgs.NET_NAME + '/conv1']
+        #     start_names = tuple(start_names)
+        #     trained_var_list = []
+        #     for var in trainable_vars:
+        #         if not var.name.startswith(start_names):
+        #             trained_var_list.append(var)
+        #     # slim.learning.train()
+        #     grads = optimizer.compute_gradients(loss, var_list=trained_var_list)
+        #     return grads
+        # else:
+        #     return optimizer.compute_gradients(loss)
+        return optimizer.compute_gradients(loss)
+
+    def enlarge_gradients_for_bias(self, gradients):
+
+        final_gradients = []
+        with tf.variable_scope("Gradient_Mult") as scope:
+            for grad, var in gradients:
+                scale = 1.0
+                if cfgs.MUTILPY_BIAS_GRADIENT and './biases' in var.name:
+                    scale = scale * cfgs.MUTILPY_BIAS_GRADIENT
+                if not np.allclose(scale, 1.0):
+                    grad = tf.multiply(grad, scale)
+                final_gradients.append((grad, var))
+        return final_gradients
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/build_whole_network2.py b/example-apps/PDD/pcb-defect-detection/libs/networks/build_whole_network2.py
new file mode 100755
index 0000000..8281440
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/build_whole_network2.py
@@ -0,0 +1,637 @@
+# -*-coding: utf-8 -*-
+
+from __future__ import absolute_import, division, print_function
+
+import os
+import tensorflow as tf
+import tensorflow.contrib.slim as slim
+import numpy as np
+
+from libs.networks import resnet
+from libs.networks import mobilenet_v2
+from libs.box_utils import encode_and_decode
+from libs.box_utils import boxes_utils
+from libs.box_utils import anchor_utils
+from libs.configs import cfgs
+from libs.losses import losses
+from libs.box_utils import show_box_in_tensor
+from libs.detection_oprations.proposal_opr import postprocess_rpn_proposals
+from libs.detection_oprations.anchor_target_layer_without_boxweight import anchor_target_layer
+from libs.detection_oprations.proposal_target_layer import proposal_target_layer
+
+
+class DetectionNetwork(object):
+
+    def __init__(self, base_network_name, is_training):
+
+        self.base_network_name = base_network_name
+        self.is_training = is_training
+        self.num_anchors_per_location = len(cfgs.ANCHOR_SCALES) * len(cfgs.ANCHOR_RATIOS)
+
+    def build_base_network(self, input_img_batch):
+
+        if self.base_network_name.startswith('resnet_v1'):
+            return resnet.resnet_base(input_img_batch, scope_name=self.base_network_name, is_training=self.is_training)
+
+        elif self.base_network_name.startswith('MobilenetV2'):
+            return mobilenet_v2.mobilenetv2_base(input_img_batch, is_training=self.is_training)
+
+        else:
+            raise ValueError('Sry, we only support resnet or mobilenet_v2')
+
+    def postprocess_fastrcnn(self, rois, bbox_ppred, scores, img_shape):
+        '''
+
+        :param rois:[-1, 4]
+        :param bbox_ppred: [-1, (cfgs.Class_num+1) * 4]
+        :param scores: [-1, cfgs.Class_num + 1]
+        :return:
+        '''
+
+        with tf.name_scope('postprocess_fastrcnn'):
+            rois = tf.stop_gradient(rois)
+            scores = tf.stop_gradient(scores)
+            bbox_ppred = tf.reshape(bbox_ppred, [-1, cfgs.CLASS_NUM + 1, 4])
+            bbox_ppred = tf.stop_gradient(bbox_ppred)
+
+            bbox_pred_list = tf.unstack(bbox_ppred, axis=1)
+            score_list = tf.unstack(scores, axis=1)
+
+            allclasses_boxes = []
+            allclasses_scores = []
+            categories = []
+            for i in range(1, cfgs.CLASS_NUM+1):
+
+                # 1. decode boxes in each class
+                tmp_encoded_box = bbox_pred_list[i]
+                tmp_score = score_list[i]
+                tmp_decoded_boxes = encode_and_decode.decode_boxes(encoded_boxes=tmp_encoded_box,
+                                                                   reference_boxes=rois,
+                                                                   scale_factors=cfgs.ROI_SCALE_FACTORS)
+                # tmp_decoded_boxes = encode_and_decode.decode_boxes(boxes=rois,
+                #                                                    deltas=tmp_encoded_box,
+                #                                                    scale_factor=cfgs.ROI_SCALE_FACTORS)
+
+                # 2. clip to img boundaries
+                tmp_decoded_boxes = boxes_utils.clip_boxes_to_img_boundaries(decode_boxes=tmp_decoded_boxes,
+                                                                             img_shape=img_shape)
+
+                # 3. NMS
+                keep = tf.image.non_max_suppression(
+                    boxes=tmp_decoded_boxes,
+                    scores=tmp_score,
+                    max_output_size=cfgs.FAST_RCNN_NMS_MAX_BOXES_PER_CLASS,
+                    iou_threshold=cfgs.FAST_RCNN_NMS_IOU_THRESHOLD)
+
+                perclass_boxes = tf.gather(tmp_decoded_boxes, keep)
+                perclass_scores = tf.gather(tmp_score, keep)
+
+                allclasses_boxes.append(perclass_boxes)
+                allclasses_scores.append(perclass_scores)
+                categories.append(tf.ones_like(perclass_scores) * i)
+
+            final_boxes = tf.concat(allclasses_boxes, axis=0)
+            final_scores = tf.concat(allclasses_scores, axis=0)
+            final_category = tf.concat(categories, axis=0)
+
+            if self.is_training:
+                '''
+                in training. We should show the detecitons in the tensorboard. So we add this.
+                '''
+                kept_indices = tf.reshape(tf.where(tf.greater_equal(final_scores, cfgs.SHOW_SCORE_THRSHOLD)), [-1])
+
+                final_boxes = tf.gather(final_boxes, kept_indices)
+                final_scores = tf.gather(final_scores, kept_indices)
+                final_category = tf.gather(final_category, kept_indices)
+
+        return final_boxes, final_scores, final_category
+
+    def roi_pooling(self, feature_maps, rois, img_shape, scope):
+        '''
+        Here use roi warping as roi_pooling
+
+        :param featuremaps_dict: feature map to crop
+        :param rois: shape is [-1, 4]. [x1, y1, x2, y2]
+        :return:
+        '''
+
+        with tf.variable_scope('ROI_Warping_'+scope):
+            img_h, img_w = tf.cast(img_shape[1], tf.float32), tf.cast(img_shape[2], tf.float32)
+            N = tf.shape(rois)[0]
+            x1, y1, x2, y2 = tf.unstack(rois, axis=1)
+
+            normalized_x1 = x1 / img_w
+            normalized_x2 = x2 / img_w
+            normalized_y1 = y1 / img_h
+            normalized_y2 = y2 / img_h
+
+            normalized_rois = tf.transpose(
+                tf.stack([normalized_y1, normalized_x1, normalized_y2, normalized_x2]), name='get_normalized_rois')
+
+            normalized_rois = tf.stop_gradient(normalized_rois)
+
+            cropped_roi_features = tf.image.crop_and_resize(feature_maps, normalized_rois,
+                                                            box_ind=tf.zeros(shape=[N],
+                                                                             dtype=tf.int32),
+                                                            crop_size=[cfgs.ROI_SIZE, cfgs.ROI_SIZE],
+                                                            name='CROP_AND_RESIZE'
+                                                            )
+            roi_features = slim.max_pool2d(cropped_roi_features,
+                                           [cfgs.ROI_POOL_KERNEL_SIZE, cfgs.ROI_POOL_KERNEL_SIZE],
+                                           stride=cfgs.ROI_POOL_KERNEL_SIZE)
+
+        return roi_features
+
+    def build_fastrcnn(self, P_list, rois_list, img_shape):
+
+        with tf.variable_scope('Fast-RCNN'):
+            # 5. ROI Pooling
+            with tf.variable_scope('rois_pooling'):
+                pooled_features_list = []
+                for level_name, p, rois in zip(cfgs.LEVLES, P_list, rois_list):  # exclude P6_rois
+                    # p = tf.Print(p, [tf.shape(p)], summarize=10, message=level_name+'SHPAE***')
+                    pooled_features = self.roi_pooling(feature_maps=p, rois=rois, img_shape=img_shape,
+                                                       scope=level_name)
+                    pooled_features_list.append(pooled_features)
+
+                pooled_features = tf.concat(pooled_features_list, axis=0) # [minibatch_size, H, W, C]
+
+            # 6. inferecne rois in Fast-RCNN to obtain fc_flatten features
+            if self.base_network_name.startswith('resnet'):
+                fc_flatten = resnet.restnet_head(inputs=pooled_features,
+                                                 is_training=self.is_training,
+                                                 scope_name=self.base_network_name)
+            elif self.base_network_name.startswith('Mobile'):
+                fc_flatten = mobilenet_v2.mobilenetv2_head(inputs=pooled_features,
+                                                           is_training=self.is_training)
+            else:
+                raise NotImplementedError('only support resnet and mobilenet')
+
+            # 7. cls and reg in Fast-RCNN
+            with slim.arg_scope([slim.fully_connected], weights_regularizer=slim.l2_regularizer(cfgs.WEIGHT_DECAY)):
+
+                cls_score = slim.fully_connected(fc_flatten,
+                                                 num_outputs=cfgs.CLASS_NUM+1,
+                                                 weights_initializer=cfgs.INITIALIZER,
+                                                 activation_fn=None, trainable=self.is_training,
+                                                 scope='cls_fc')
+
+                bbox_pred = slim.fully_connected(fc_flatten,
+                                                 num_outputs=(cfgs.CLASS_NUM+1)*4,
+                                                 weights_initializer=cfgs.BBOX_INITIALIZER,
+                                                 activation_fn=None, trainable=self.is_training,
+                                                 scope='reg_fc')
+                # for convient. It also produce (cls_num +1) bboxes
+
+                cls_score = tf.reshape(cls_score, [-1, cfgs.CLASS_NUM+1])
+                bbox_pred = tf.reshape(bbox_pred, [-1, 4*(cfgs.CLASS_NUM+1)])
+
+        return bbox_pred, cls_score
+
+    def assign_levels(self, all_rois, labels=None, bbox_targets=None):
+        '''
+
+        :param all_rois:
+        :param labels:
+        :param bbox_targets:
+        :return:
+        '''
+        with tf.name_scope('assign_levels'):
+            # all_rois = tf.Print(all_rois, [tf.shape(all_rois)], summarize=10, message='ALL_ROIS_SHAPE*****')
+            xmin, ymin, xmax, ymax = tf.unstack(all_rois, axis=1)
+
+            h = tf.maximum(0., ymax - ymin)
+            w = tf.maximum(0., xmax - xmin)
+
+            levels = tf.floor(4. + tf.log(tf.sqrt(w * h + 1e-8) / 224.0) / tf.log(2.))  # 4 + log_2(***)
+            # use floor instead of round
+
+            min_level = int(cfgs.LEVLES[0][-1])
+            max_level = min(5, int(cfgs.LEVLES[-1][-1]))
+            levels = tf.maximum(levels, tf.ones_like(levels) * min_level)  # level minimum is 2
+            levels = tf.minimum(levels, tf.ones_like(levels) * max_level)  # level maximum is 5
+
+            levels = tf.stop_gradient(tf.reshape(levels, [-1]))
+
+            def get_rois(levels, level_i, rois, labels, bbox_targets):
+
+                level_i_indices = tf.reshape(tf.where(tf.equal(levels, level_i)), [-1])
+                tf.summary.scalar('LEVEL/LEVEL_%d_rois_NUM'%level_i, tf.shape(level_i_indices)[0])
+                level_i_rois = tf.gather(rois, level_i_indices)
+
+                # if self.is_training:
+                #     level_i_rois = tf.stop_gradient(tf.concat([level_i_rois, [[0, 0, 0., 0.]]], axis=0))
+                #     # to avoid the num of level i rois is 0.0, which will broken the BP in tf
+                #
+                #     level_i_labels = tf.gather(labels, level_i_indices)
+                #     level_i_labels = tf.stop_gradient(tf.concat([level_i_labels, [0]], axis=0))
+                #
+                #     level_i_targets = tf.gather(bbox_targets, level_i_indices)
+                #     level_i_targets = tf.stop_gradient(tf.concat([level_i_targets,
+                #                                                   tf.zeros(shape=(1, 4*(cfgs.CLASS_NUM+1)), dtype=tf.float32)],
+                #                                                  axis=0))
+                #
+                #     return level_i_rois, level_i_labels, level_i_targets
+                if self.is_training:
+                    level_i_labels = tf.gather(labels, level_i_indices)
+                    level_i_targets = tf.gather(bbox_targets, level_i_indices)
+                    return level_i_rois, level_i_labels, level_i_targets
+                else:
+                    return level_i_rois, None, None
+
+            rois_list = []
+            labels_list = []
+            targets_list = []
+            for i in range(min_level, max_level+1):
+                P_i_rois, P_i_labels, P_i_targets = get_rois(levels, level_i=i, rois=all_rois,
+                                                             labels=labels,
+                                                             bbox_targets=bbox_targets)
+                rois_list.append(P_i_rois)
+                labels_list.append(P_i_labels)
+                targets_list.append(P_i_targets)
+
+            if self.is_training:
+                all_labels = tf.concat(labels_list, axis=0)
+                all_targets = tf.concat(targets_list, axis=0)
+
+                return rois_list, \
+                       tf.stop_gradient(all_labels), \
+                       tf.stop_gradient(all_targets)
+            else:
+                return rois_list  # [P2_rois, P3_rois, P4_rois, P5_rois] Note: P6 do not assign rois
+    # ---------------------------------------------------------------------------------------
+
+    def add_anchor_img_smry(self, img, anchors, labels):
+
+        positive_anchor_indices = tf.reshape(tf.where(tf.greater_equal(labels, 1)), [-1])
+        negative_anchor_indices = tf.reshape(tf.where(tf.equal(labels, 0)), [-1])
+
+        positive_anchor = tf.gather(anchors, positive_anchor_indices)
+        negative_anchor = tf.gather(anchors, negative_anchor_indices)
+
+        pos_in_img = show_box_in_tensor.only_draw_boxes(img_batch=img,
+                                                        boxes=positive_anchor)
+        neg_in_img = show_box_in_tensor.only_draw_boxes(img_batch=img,
+                                                        boxes=negative_anchor)
+
+        tf.summary.image('positive_anchor', pos_in_img)
+        tf.summary.image('negative_anchors', neg_in_img)
+
+    def add_roi_batch_img_smry(self, img, rois, labels):
+        positive_roi_indices = tf.reshape(tf.where(tf.greater_equal(labels, 1)), [-1])
+
+        negative_roi_indices = tf.reshape(tf.where(tf.equal(labels, 0)), [-1])
+
+        pos_roi = tf.gather(rois, positive_roi_indices)
+        neg_roi = tf.gather(rois, negative_roi_indices)
+
+
+        pos_in_img = show_box_in_tensor.only_draw_boxes(img_batch=img,
+                                                               boxes=pos_roi)
+        neg_in_img = show_box_in_tensor.only_draw_boxes(img_batch=img,
+                                                               boxes=neg_roi)
+        tf.summary.image('pos_rois', pos_in_img)
+        tf.summary.image('neg_rois', neg_in_img)
+
+    def build_loss(self, rpn_box_pred, rpn_bbox_targets, rpn_cls_score, rpn_labels,
+                   bbox_pred, bbox_targets, cls_score, labels):
+        '''
+
+        :param rpn_box_pred: [-1, 4]
+        :param rpn_bbox_targets: [-1, 4]
+        :param rpn_cls_score: [-1]
+        :param rpn_labels: [-1]
+        :param bbox_pred: [-1, 4*(cls_num+1)]
+        :param bbox_targets: [-1, 4*(cls_num+1)]
+        :param cls_score: [-1, cls_num+1]
+        :param labels: [-1]
+        :return:
+        '''
+        with tf.variable_scope('build_loss') as sc:
+            with tf.variable_scope('rpn_loss'):
+
+                rpn_bbox_loss = losses.smooth_l1_loss_rpn(bbox_pred=rpn_box_pred,
+                                                          bbox_targets=rpn_bbox_targets,
+                                                          label=rpn_labels,
+                                                          sigma=cfgs.RPN_SIGMA)
+                # rpn_cls_loss:
+                # rpn_cls_score = tf.reshape(rpn_cls_score, [-1, 2])
+                # rpn_labels = tf.reshape(rpn_labels, [-1])
+                # ensure rpn_labels shape is [-1]
+                rpn_select = tf.reshape(tf.where(tf.not_equal(rpn_labels, -1)), [-1])
+                rpn_cls_score = tf.reshape(tf.gather(rpn_cls_score, rpn_select), [-1, 2])
+                rpn_labels = tf.reshape(tf.gather(rpn_labels, rpn_select), [-1])
+                rpn_cls_loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=rpn_cls_score,
+                                                                                             labels=rpn_labels))
+
+                rpn_cls_loss = rpn_cls_loss * cfgs.RPN_CLASSIFICATION_LOSS_WEIGHT
+                rpn_bbox_loss = rpn_bbox_loss * cfgs.RPN_LOCATION_LOSS_WEIGHT
+
+            with tf.variable_scope('FastRCNN_loss'):
+                if not cfgs.FAST_RCNN_MINIBATCH_SIZE == -1:
+                    bbox_loss = losses.smooth_l1_loss_rcnn(bbox_pred=bbox_pred,
+                                                           bbox_targets=bbox_targets,
+                                                           label=labels,
+                                                           num_classes=cfgs.CLASS_NUM + 1,
+                                                           sigma=cfgs.FASTRCNN_SIGMA)
+
+                    # cls_score = tf.reshape(cls_score, [-1, cfgs.CLASS_NUM + 1])
+                    # labels = tf.reshape(labels, [-1])
+                    cls_loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(
+                        logits=cls_score,
+                        labels=labels))  # beacause already sample before
+                else:
+                    ''' 
+                    applying OHEM here
+                    '''
+                    print(20 * "@@")
+                    print("@@" + 10 * " " + "TRAIN WITH OHEM ...")
+                    print(20 * "@@")
+                    cls_loss = bbox_loss = losses.sum_ohem_loss(
+                        cls_score=cls_score,
+                        label=labels,
+                        bbox_targets=bbox_targets,
+                        nr_ohem_sampling=128,
+                        nr_classes=cfgs.CLASS_NUM + 1)
+                cls_loss = cls_loss * cfgs.FAST_RCNN_CLASSIFICATION_LOSS_WEIGHT
+                bbox_loss = bbox_loss * cfgs.FAST_RCNN_LOCATION_LOSS_WEIGHT
+            loss_dict = {
+                'rpn_cls_loss': rpn_cls_loss,
+                'rpn_loc_loss': rpn_bbox_loss,
+                'fastrcnn_cls_loss': cls_loss,
+                'fastrcnn_loc_loss': bbox_loss
+            }
+        return loss_dict
+
+
+    def build_whole_detection_network(self, input_img_batch, gtboxes_batch):
+
+        if self.is_training:
+            # ensure shape is [M, 5]
+            gtboxes_batch = tf.reshape(gtboxes_batch, [-1, 5])
+            gtboxes_batch = tf.cast(gtboxes_batch, tf.float32)
+
+        img_shape = tf.shape(input_img_batch)
+
+        # 1. build base network
+        P_dict = self.build_base_network(input_img_batch)  # [P2, P3, P4, P5, P6]
+
+        # 2. build fpn  by build rpn for each level
+        with tf.variable_scope("build_FPN", regularizer=slim.l2_regularizer(cfgs.WEIGHT_DECAY)):
+            fpn_box_delta = {}
+            fpn_cls_score = {}
+            fpn_cls_prob = {}
+            for key in cfgs.LEVLES:
+                if cfgs.SHARE_HEADS:
+                    reuse_flag = None if key == cfgs.LEVLES[0] else True
+                    scope_list = ['fpn_conv/3x3', 'fpn_cls_score', 'fpn_bbox_pred']
+                else:
+                    reuse_flag = None
+                    scope_list= ['fpn_conv/3x3_%s' % key, 'fpn_cls_score_%s' % key, 'fpn_bbox_pred_%s' % key]
+                rpn_conv3x3 = slim.conv2d(
+                    P_dict[key], 512, [3, 3],
+                    trainable=self.is_training, weights_initializer=cfgs.INITIALIZER, padding="SAME",
+                    activation_fn=tf.nn.relu,
+                    scope=scope_list[0],
+                    reuse=reuse_flag)
+                rpn_cls_score = slim.conv2d(rpn_conv3x3, self.num_anchors_per_location*2, [1, 1], stride=1,
+                                            trainable=self.is_training, weights_initializer=cfgs.INITIALIZER,
+                                            activation_fn=None, padding="VALID",
+                                            scope=scope_list[1],
+                                            reuse=reuse_flag)
+                rpn_box_delta = slim.conv2d(rpn_conv3x3, self.num_anchors_per_location*4, [1, 1], stride=1,
+                                            trainable=self.is_training, weights_initializer=cfgs.BBOX_INITIALIZER,
+                                            activation_fn=None, padding="VALID",
+                                            scope=scope_list[2],
+                                            reuse=reuse_flag)
+                fpn_box_delta[key] = tf.reshape(rpn_box_delta, [-1, 4])
+                fpn_cls_score[key] = tf.reshape(rpn_cls_score, [-1, 2])
+                fpn_cls_prob[key] = slim.softmax(fpn_cls_score[key])
+
+        # 3. generate anchors for fpn. (by generate for each level)
+        anchors_dict = {}
+        anchor_list = []
+        with tf.name_scope("generate_FPN_anchors"):
+            for key in cfgs.LEVLES:
+                p_h, p_w = tf.to_float(tf.shape(P_dict[key])[1]), tf.to_float(tf.shape(P_dict[key])[2])
+                id_ = int(key[-1]) - int(cfgs.LEVLES[0][-1]) # such as : 2-2, 3-3
+                tmp_anchors = anchor_utils.make_anchors(base_anchor_size=cfgs.BASE_ANCHOR_SIZE_LIST[id_],
+                                                        anchor_scales=cfgs.ANCHOR_SCALES,
+                                                        anchor_ratios=cfgs.ANCHOR_RATIOS,
+                                                        stride=cfgs.ANCHOR_STRIDE_LIST[id_],
+                                                        featuremap_height=p_h,
+                                                        featuremap_width=p_w,
+                                                        name='%s_make_anchors' % key)
+                anchors_dict[key] = tmp_anchors
+                anchor_list.append(tmp_anchors)
+        all_anchors = tf.concat(anchor_list, axis=0)
+
+        # 4. postprocess fpn proposals. such as: decode, clip, NMS
+        #    Need to Note: Here we NMS for each level instead of NMS for all anchors.
+        rois_list = []
+        rois_scores_list = []
+        with tf.name_scope("postproces_fpn"):
+            for key in cfgs.LEVLES:
+                tmp_rois, tmp_roi_scores = postprocess_rpn_proposals(rpn_bbox_pred=fpn_box_delta[key],
+                                                                     rpn_cls_prob=fpn_cls_prob[key],
+                                                                     img_shape=img_shape,
+                                                                     anchors=anchors_dict[key],
+                                                                     is_training=self.is_training)
+                rois_list.append(tmp_rois)
+                rois_scores_list.append(tmp_roi_scores)
+            allrois = tf.concat(rois_list, axis=0)
+            allrois_scores = tf.concat(rois_scores_list, axis=0)
+            fpn_topk = cfgs.FPN_TOP_K_PER_LEVEL_TRAIN if self.is_training else cfgs.FPN_TOP_K_PER_LEVEL_TEST
+            topk = tf.minimum(fpn_topk, tf.shape(allrois)[0])
+
+            rois_scores, topk_indices = tf.nn.top_k(allrois_scores, k=topk)
+
+            rois = tf.stop_gradient(tf.gather(allrois, topk_indices))
+            rois_scores = tf.stop_gradient(rois_scores)
+
+            # +++++++++++++++++++++++++++++++++++++add img smry+++++++++++++++++++++++++++++++++++++++++++++++++++++++
+            if self.is_training:
+                score_gre_05 = tf.reshape(tf.where(tf.greater_equal(rois_scores, 0.5)), [-1])
+                score_gre_05_rois = tf.gather(rois, score_gre_05)
+                score_gre_05_score = tf.gather(rois_scores, score_gre_05)
+                score_gre_05_in_img = show_box_in_tensor.draw_boxes_with_scores(img_batch=input_img_batch,
+                                                                                boxes=score_gre_05_rois,
+                                                                                scores=score_gre_05_score)
+                tf.summary.image('score_greater_05_rois', score_gre_05_in_img)
+            # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+        # sample for fpn. We should concat all the anchors
+        if self.is_training:
+            with tf.variable_scope('sample_anchors_minibatch'):
+                fpn_labels, fpn_bbox_targets = \
+                    tf.py_func(
+                        anchor_target_layer,
+                        [gtboxes_batch, img_shape, all_anchors],
+                        [tf.float32, tf.float32])
+                fpn_bbox_targets = tf.reshape(fpn_bbox_targets, [-1, 4])
+                fpn_labels = tf.to_int32(fpn_labels, name="to_int32")
+                fpn_labels = tf.reshape(fpn_labels, [-1])
+                self.add_anchor_img_smry(input_img_batch, all_anchors, fpn_labels)
+
+            with tf.control_dependencies([fpn_labels]):
+                with tf.variable_scope('sample_RCNN_minibatch'):
+                    rois, labels, bbox_targets = \
+                    tf.py_func(proposal_target_layer,
+                               [rois, gtboxes_batch],
+                               [tf.float32, tf.float32, tf.float32])
+                    rois = tf.reshape(rois, [-1, 4])
+                    labels = tf.to_int32(labels)
+                    labels = tf.reshape(labels, [-1])
+                    bbox_targets = tf.reshape(bbox_targets, [-1, 4*(cfgs.CLASS_NUM+1)])
+                    self.add_roi_batch_img_smry(input_img_batch, rois, labels)
+        if self.is_training:
+            rois_list, labels, bbox_targets = self.assign_levels(all_rois=rois,
+                                                                 labels=labels,
+                                                                 bbox_targets=bbox_targets)
+        else:
+            rois_list = self.assign_levels(all_rois=rois)  # rois_list: [P2_rois, P3_rois, P4_rois, P5_rois]
+
+        # -------------------------------------------------------------------------------------------------------------#
+        #                                            Fast-RCNN                                                         #
+        # -------------------------------------------------------------------------------------------------------------#
+
+        # 5. build Fast-RCNN
+        # rois = tf.Print(rois, [tf.shape(rois)], 'rois shape', summarize=10)
+        bbox_pred, cls_score = self.build_fastrcnn(P_list=[P_dict[key] for key in cfgs.LEVLES],
+                                                   rois_list=rois_list,
+                                                   img_shape=img_shape)
+        # bbox_pred shape: [-1, 4*(cls_num+1)].
+        # cls_score shape： [-1, cls_num+1]
+
+        cls_prob = slim.softmax(cls_score, 'cls_prob')
+
+
+        # ----------------------------------------------add smry-------------------------------------------------------
+        if self.is_training:
+            cls_category = tf.argmax(cls_prob, axis=1)
+            fast_acc = tf.reduce_mean(tf.to_float(tf.equal(cls_category, tf.to_int64(labels))))
+            tf.summary.scalar('ACC/fast_acc', fast_acc)
+
+        rois = tf.concat(rois_list, axis=0, name='concat_rois')
+        #  6. postprocess_fastrcnn
+        if not self.is_training:
+            return self.postprocess_fastrcnn(rois=rois, bbox_ppred=bbox_pred, scores=cls_prob, img_shape=img_shape)
+        else:
+            '''
+            when trian. We need build Loss
+            '''
+            loss_dict = self.build_loss(rpn_box_pred=tf.concat([fpn_box_delta[key] for key in cfgs.LEVLES], axis=0),
+                                        rpn_bbox_targets=fpn_bbox_targets,
+                                        rpn_cls_score=tf.concat([fpn_cls_score[key] for key in cfgs.LEVLES], axis=0),
+                                        rpn_labels=fpn_labels,
+                                        bbox_pred=bbox_pred,
+                                        bbox_targets=bbox_targets,
+                                        cls_score=cls_score,
+                                        labels=labels)
+
+            final_bbox, final_scores, final_category = self.postprocess_fastrcnn(rois=rois,
+                                                                                 bbox_ppred=bbox_pred,
+                                                                                 scores=cls_prob,
+                                                                                 img_shape=img_shape)
+            return final_bbox, final_scores, final_category, loss_dict
+
+    def get_restorer(self):
+        checkpoint_path = tf.train.latest_checkpoint(os.path.join(cfgs.TRAINED_CKPT, cfgs.VERSION))
+
+        if checkpoint_path != None:
+            restorer = tf.train.Saver()
+            print("model restore from :", checkpoint_path)
+        else:
+            checkpoint_path = cfgs.PRETRAINED_CKPT
+            print("model restore from pretrained mode, path is :", checkpoint_path)
+
+            model_variables = slim.get_model_variables()
+            # for var in model_variables:
+            #     print(var.name)
+            # print(20*"__++__++__")
+
+            def name_in_ckpt_rpn(var):
+                return var.op.name
+
+            def name_in_ckpt_fastrcnn_head(var):
+                '''
+                Fast-RCNN/resnet_v1_50/block4 -->resnet_v1_50/block4
+                Fast-RCNN/MobilenetV2/** -- > MobilenetV2 **
+                :param var:
+                :return:
+                '''
+                return '/'.join(var.op.name.split('/')[1:])
+            nameInCkpt_Var_dict = {}
+            for var in model_variables:
+                if var.name.startswith(self.base_network_name):
+                    var_name_in_ckpt = name_in_ckpt_rpn(var)
+                    nameInCkpt_Var_dict[var_name_in_ckpt] = var
+            restore_variables = nameInCkpt_Var_dict
+            for key, item in restore_variables.items():
+                print("var_in_graph: ", item.name)
+                print("var_in_ckpt: ", key)
+                print(20*"___")
+            restorer = tf.train.Saver(restore_variables)
+            print(20 * "****")
+            print("restore from pretrained_weighs in IMAGE_NET")
+        return restorer, checkpoint_path
+
+    def get_gradients(self, optimizer, loss):
+        '''
+
+        :param optimizer:
+        :param loss:
+        :return:
+
+        return vars and grads that not be fixed
+        '''
+
+        # if cfgs.FIXED_BLOCKS > 0:
+        #     trainable_vars = tf.trainable_variables()
+        #     # trained_vars = slim.get_trainable_variables()
+        #     start_names = [cfgs.NET_NAME + '/block%d'%i for i in range(1, cfgs.FIXED_BLOCKS+1)] + \
+        #                   [cfgs.NET_NAME + '/conv1']
+        #     start_names = tuple(start_names)
+        #     trained_var_list = []
+        #     for var in trainable_vars:
+        #         if not var.name.startswith(start_names):
+        #             trained_var_list.append(var)
+        #     # slim.learning.train()
+        #     grads = optimizer.compute_gradients(loss, var_list=trained_var_list)
+        #     return grads
+        # else:
+        #     return optimizer.compute_gradients(loss)
+        return optimizer.compute_gradients(loss)
+
+    def enlarge_gradients_for_bias(self, gradients):
+
+        final_gradients = []
+        with tf.variable_scope("Gradient_Mult") as scope:
+            for grad, var in gradients:
+                scale = 1.0
+                if cfgs.MUTILPY_BIAS_GRADIENT and './biases' in var.name:
+                    scale = scale * cfgs.MUTILPY_BIAS_GRADIENT
+                if not np.allclose(scale, 1.0):
+                    grad = tf.multiply(grad, scale)
+                final_gradients.append((grad, var))
+        return final_gradients
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/mobilenet/README.md b/example-apps/PDD/pcb-defect-detection/libs/networks/mobilenet/README.md
new file mode 100755
index 0000000..ba62406
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/mobilenet/README.md
@@ -0,0 +1,12 @@
+# Mobilenet V2
+This folder contains building code for Mobilenet V2, based on
+[Inverted Residuals and Linear Bottlenecks: Mobile Networks for Classification, Detection and Segmentation]
+(https://arxiv.org/abs/1801.04381)
+
+# Pretrained model
+TODO
+
+# Example
+TODO
+
+
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/mobilenet/__init__.py b/example-apps/PDD/pcb-defect-detection/libs/networks/mobilenet/__init__.py
new file mode 100755
index 0000000..e69de29
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/mobilenet/conv_blocks.py b/example-apps/PDD/pcb-defect-detection/libs/networks/mobilenet/conv_blocks.py
new file mode 100755
index 0000000..029bd11
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/mobilenet/conv_blocks.py
@@ -0,0 +1,352 @@
+# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Convolution blocks for mobilenet."""
+import contextlib
+import functools
+
+import tensorflow as tf
+
+slim = tf.contrib.slim
+
+
+def _fixed_padding(inputs, kernel_size, rate=1):
+  """Pads the input along the spatial dimensions independently of input size.
+
+  Pads the input such that if it was used in a convolution with 'VALID' padding,
+  the output would have the same dimensions as if the unpadded input was used
+  in a convolution with 'SAME' padding.
+
+  Args:
+    inputs: A tensor of size [batch, height_in, width_in, channels].
+    kernel_size: The kernel to be used in the conv2d or max_pool2d operation.
+    rate: An integer, rate for atrous convolution.
+
+  Returns:
+    output: A tensor of size [batch, height_out, width_out, channels] with the
+      input, either intact (if kernel_size == 1) or padded (if kernel_size > 1).
+  """
+  kernel_size_effective = [kernel_size[0] + (kernel_size[0] - 1) * (rate - 1),
+                           kernel_size[0] + (kernel_size[0] - 1) * (rate - 1)]
+  pad_total = [kernel_size_effective[0] - 1, kernel_size_effective[1] - 1]
+  pad_beg = [pad_total[0] // 2, pad_total[1] // 2]
+  pad_end = [pad_total[0] - pad_beg[0], pad_total[1] - pad_beg[1]]
+  padded_inputs = tf.pad(inputs, [[0, 0], [pad_beg[0], pad_end[0]],
+                                  [pad_beg[1], pad_end[1]], [0, 0]])
+  return padded_inputs
+
+
+def _make_divisible(v, divisor, min_value=None):
+  if min_value is None:
+    min_value = divisor
+  new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
+  # Make sure that round down does not go down by more than 10%.
+  if new_v < 0.9 * v:
+    new_v += divisor
+  return new_v
+
+
+def _split_divisible(num, num_ways, divisible_by=8):
+  """Evenly splits num, num_ways so each piece is a multiple of divisible_by."""
+  assert num % divisible_by == 0
+  assert num / num_ways >= divisible_by
+  # Note: want to round down, we adjust each split to match the total.
+  base = num // num_ways // divisible_by * divisible_by
+  result = []
+  accumulated = 0
+  for i in range(num_ways):
+    r = base
+    while accumulated + r < num * (i + 1) / num_ways:
+      r += divisible_by
+    result.append(r)
+    accumulated += r
+  assert accumulated == num
+  return result
+
+
+@contextlib.contextmanager
+def _v1_compatible_scope_naming(scope):
+  if scope is None:  # Create uniqified separable blocks.
+    with tf.variable_scope(None, default_name='separable') as s, \
+         tf.name_scope(s.original_name_scope):
+      yield ''
+  else:
+    # We use scope_depthwise, scope_pointwise for compatibility with V1 ckpts.
+    # which provide numbered scopes.
+    scope += '_'
+    yield scope
+
+
+@slim.add_arg_scope
+def split_separable_conv2d(input_tensor,
+                           num_outputs,
+                           scope=None,
+                           normalizer_fn=None,
+                           stride=1,
+                           rate=1,
+                           endpoints=None,
+                           use_explicit_padding=False):
+  """Separable mobilenet V1 style convolution.
+
+  Depthwise convolution, with default non-linearity,
+  followed by 1x1 depthwise convolution.  This is similar to
+  slim.separable_conv2d, but differs in tha it applies batch
+  normalization and non-linearity to depthwise. This  matches
+  the basic building of Mobilenet Paper
+  (https://arxiv.org/abs/1704.04861)
+
+  Args:
+    input_tensor: input
+    num_outputs: number of outputs
+    scope: optional name of the scope. Note if provided it will use
+    scope_depthwise for deptwhise, and scope_pointwise for pointwise.
+    normalizer_fn: which normalizer function to use for depthwise/pointwise
+    stride: stride
+    rate: output rate (also known as dilation rate)
+    endpoints: optional, if provided, will export additional tensors to it.
+    use_explicit_padding: Use 'VALID' padding for convolutions, but prepad
+      inputs so that the output dimensions are the same as if 'SAME' padding
+      were used.
+
+  Returns:
+    output tesnor
+  """
+
+  with _v1_compatible_scope_naming(scope) as scope:
+    dw_scope = scope + 'depthwise'
+    endpoints = endpoints if endpoints is not None else {}
+    kernel_size = [3, 3]
+    padding = 'SAME'
+    if use_explicit_padding:
+      padding = 'VALID'
+      input_tensor = _fixed_padding(input_tensor, kernel_size, rate)
+    net = slim.separable_conv2d(
+        input_tensor,
+        None,
+        kernel_size,
+        depth_multiplier=1,
+        stride=stride,
+        rate=rate,
+        normalizer_fn=normalizer_fn,
+        padding=padding,
+        scope=dw_scope)
+
+    endpoints[dw_scope] = net
+
+    pw_scope = scope + 'pointwise'
+    net = slim.conv2d(
+        net,
+        num_outputs, [1, 1],
+        stride=1,
+        normalizer_fn=normalizer_fn,
+        scope=pw_scope)
+    endpoints[pw_scope] = net
+  return net
+
+
+def expand_input_by_factor(n, divisible_by=8):
+  return lambda num_inputs, **_: _make_divisible(num_inputs * n, divisible_by)
+
+
+@slim.add_arg_scope
+def expanded_conv(input_tensor,
+                  num_outputs,
+                  expansion_size=expand_input_by_factor(6),
+                  stride=1,
+                  rate=1,
+                  kernel_size=(3, 3),
+                  residual=True,
+                  normalizer_fn=None,
+                  split_projection=1,
+                  split_expansion=1,
+                  expansion_transform=None,
+                  depthwise_location='expansion',
+                  depthwise_channel_multiplier=1,
+                  endpoints=None,
+                  use_explicit_padding=False,
+                  scope=None):
+  """Depthwise Convolution Block with expansion.
+
+  Builds a composite convolution that has the following structure
+  expansion (1x1) -> depthwise (kernel_size) -> projection (1x1)
+
+  Args:
+    input_tensor: input
+    num_outputs: number of outputs in the final layer.
+    expansion_size: the size of expansion, could be a constant or a callable.
+      If latter it will be provided 'num_inputs' as an input. For forward
+      compatibility it should accept arbitrary keyword arguments.
+      Default will expand the input by factor of 6.
+    stride: depthwise stride
+    rate: depthwise rate
+    kernel_size: depthwise kernel
+    residual: whether to include residual connection between input
+      and output.
+    normalizer_fn: batchnorm or otherwise
+    split_projection: how many ways to split projection operator
+      (that is conv expansion->bottleneck)
+    split_expansion: how many ways to split expansion op
+      (that is conv bottleneck->expansion) ops will keep depth divisible
+      by this value.
+    expansion_transform: Optional function that takes expansion
+      as a single input and returns output.
+    depthwise_location: where to put depthwise covnvolutions supported
+      values None, 'input', 'output', 'expansion'
+    depthwise_channel_multiplier: depthwise channel multiplier:
+    each input will replicated (with different filters)
+    that many times. So if input had c channels,
+    output will have c x depthwise_channel_multpilier.
+    endpoints: An optional dictionary into which intermediate endpoints are
+      placed. The keys "expansion_output", "depthwise_output",
+      "projection_output" and "expansion_transform" are always populated, even
+      if the corresponding functions are not invoked.
+    use_explicit_padding: Use 'VALID' padding for convolutions, but prepad
+      inputs so that the output dimensions are the same as if 'SAME' padding
+      were used.
+    scope: optional scope.
+
+  Returns:
+    Tensor of depth num_outputs
+
+  Raises:
+    TypeError: on inval
+  """
+  with tf.variable_scope(scope, default_name='expanded_conv') as s, \
+       tf.name_scope(s.original_name_scope):
+    prev_depth = input_tensor.get_shape().as_list()[3]
+    if  depthwise_location not in [None, 'input', 'output', 'expansion']:
+      raise TypeError('%r is unknown value for depthwise_location' %
+                      depthwise_location)
+    padding = 'SAME'
+    if use_explicit_padding:
+      padding = 'VALID'
+    depthwise_func = functools.partial(
+        slim.separable_conv2d,
+        num_outputs=None,
+        kernel_size=kernel_size,
+        depth_multiplier=depthwise_channel_multiplier,
+        stride=stride,
+        rate=rate,
+        normalizer_fn=normalizer_fn,
+        padding=padding,
+        scope='depthwise')
+    # b1 -> b2 * r -> b2
+    #   i -> (o * r) (bottleneck) -> o
+    input_tensor = tf.identity(input_tensor, 'input')
+    net = input_tensor
+
+    if depthwise_location == 'input':
+      if use_explicit_padding:
+        net = _fixed_padding(net, kernel_size, rate)
+      net = depthwise_func(net, activation_fn=None)
+
+    if callable(expansion_size):
+      inner_size = expansion_size(num_inputs=prev_depth)
+    else:
+      inner_size = expansion_size
+
+    if inner_size > net.shape[3]:
+      net = split_conv(
+          net,
+          inner_size,
+          num_ways=split_expansion,
+          scope='expand',
+          stride=1,
+          normalizer_fn=normalizer_fn)
+      net = tf.identity(net, 'expansion_output')
+    if endpoints is not None:
+      endpoints['expansion_output'] = net
+
+    if depthwise_location == 'expansion':
+      if use_explicit_padding:
+        net = _fixed_padding(net, kernel_size, rate)
+      net = depthwise_func(net)
+
+    net = tf.identity(net, name='depthwise_output')
+    if endpoints is not None:
+      endpoints['depthwise_output'] = net
+    if expansion_transform:
+      net = expansion_transform(expansion_tensor=net, input_tensor=input_tensor)
+    # Note in contrast with expansion, we always have
+    # projection to produce the desired output size.
+    net = split_conv(
+        net,
+        num_outputs,
+        num_ways=split_projection,
+        stride=1,
+        scope='project',
+        normalizer_fn=normalizer_fn,
+        activation_fn=tf.identity)
+    if endpoints is not None:
+      endpoints['projection_output'] = net
+    if depthwise_location == 'output':
+      if use_explicit_padding:
+        net = _fixed_padding(net, kernel_size, rate)
+      net = depthwise_func(net, activation_fn=None)
+
+    if callable(residual):  # custom residual
+      net = residual(input_tensor=input_tensor, output_tensor=net)
+    elif (residual and
+          # stride check enforces that we don't add residuals when spatial
+          # dimensions are None
+          stride == 1 and
+          # Depth matches
+          net.get_shape().as_list()[3] ==
+          input_tensor.get_shape().as_list()[3]):
+      net += input_tensor
+    return tf.identity(net, name='output')
+
+
+def split_conv(input_tensor,
+               num_outputs,
+               num_ways,
+               scope,
+               divisible_by=8,
+               **kwargs):
+  """Creates a split convolution.
+
+  Split convolution splits the input and output into
+  'num_blocks' blocks of approximately the same size each,
+  and only connects $i$-th input to $i$ output.
+
+  Args:
+    input_tensor: input tensor
+    num_outputs: number of output filters
+    num_ways: num blocks to split by.
+    scope: scope for all the operators.
+    divisible_by: make sure that every part is divisiable by this.
+    **kwargs: will be passed directly into conv2d operator
+  Returns:
+    tensor
+  """
+  b = input_tensor.get_shape().as_list()[3]
+
+  if num_ways == 1 or min(b // num_ways,
+                          num_outputs // num_ways) < divisible_by:
+    # Don't do any splitting if we end up with less than 8 filters
+    # on either side.
+    return slim.conv2d(input_tensor, num_outputs, [1, 1], scope=scope, **kwargs)
+
+  outs = []
+  input_splits = _split_divisible(b, num_ways, divisible_by=divisible_by)
+  output_splits = _split_divisible(
+      num_outputs, num_ways, divisible_by=divisible_by)
+  inputs = tf.split(input_tensor, input_splits, axis=3, name='split_' + scope)
+  base = scope
+  for i, (input_tensor, out_size) in enumerate(zip(inputs, output_splits)):
+    scope = base + '_part_%d' % (i,)
+    n = slim.conv2d(input_tensor, out_size, [1, 1], scope=scope, **kwargs)
+    n = tf.identity(n, scope + '_output')
+    outs.append(n)
+  return tf.concat(outs, 3, name=scope + '_concat')
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/mobilenet/mobilenet.py b/example-apps/PDD/pcb-defect-detection/libs/networks/mobilenet/mobilenet.py
new file mode 100755
index 0000000..3c8ca50
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/mobilenet/mobilenet.py
@@ -0,0 +1,433 @@
+# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Mobilenet Base Class."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+import collections
+import contextlib
+import copy
+import os
+
+import tensorflow as tf
+
+
+slim = tf.contrib.slim
+
+
+@slim.add_arg_scope
+def apply_activation(x, name=None, activation_fn=None):
+  return activation_fn(x, name=name) if activation_fn else x
+
+
+def _fixed_padding(inputs, kernel_size, rate=1):
+  """Pads the input along the spatial dimensions independently of input size.
+
+  Pads the input such that if it was used in a convolution with 'VALID' padding,
+  the output would have the same dimensions as if the unpadded input was used
+  in a convolution with 'SAME' padding.
+
+  Args:
+    inputs: A tensor of size [batch, height_in, width_in, channels].
+    kernel_size: The kernel to be used in the conv2d or max_pool2d operation.
+    rate: An integer, rate for atrous convolution.
+
+  Returns:
+    output: A tensor of size [batch, height_out, width_out, channels] with the
+      input, either intact (if kernel_size == 1) or padded (if kernel_size > 1).
+  """
+  kernel_size_effective = [kernel_size[0] + (kernel_size[0] - 1) * (rate - 1),
+                           kernel_size[0] + (kernel_size[0] - 1) * (rate - 1)]
+  pad_total = [kernel_size_effective[0] - 1, kernel_size_effective[1] - 1]
+  pad_beg = [pad_total[0] // 2, pad_total[1] // 2]
+  pad_end = [pad_total[0] - pad_beg[0], pad_total[1] - pad_beg[1]]
+  padded_inputs = tf.pad(inputs, [[0, 0], [pad_beg[0], pad_end[0]],
+                                  [pad_beg[1], pad_end[1]], [0, 0]])
+  return padded_inputs
+
+
+def _make_divisible(v, divisor, min_value=None):
+  if min_value is None:
+    min_value = divisor
+  new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
+  # Make sure that round down does not go down by more than 10%.
+  if new_v < 0.9 * v:
+    new_v += divisor
+  return new_v
+
+
+@contextlib.contextmanager
+def _set_arg_scope_defaults(defaults):
+  """Sets arg scope defaults for all items present in defaults.
+
+  Args:
+    defaults: dictionary/list of pairs, containing a mapping from
+    function to a dictionary of default args.
+
+  Yields:
+    context manager where all defaults are set.
+  """
+  if hasattr(defaults, 'items'):
+    items = defaults.items()
+  else:
+    items = defaults
+  if not items:
+    yield
+  else:
+    func, default_arg = items[0]
+    with slim.arg_scope(func, **default_arg):
+      with _set_arg_scope_defaults(items[1:]):
+        yield
+
+
+@slim.add_arg_scope
+def depth_multiplier(output_params,
+                     multiplier,
+                     divisible_by=8,
+                     min_depth=8,
+                     **unused_kwargs):
+  if 'num_outputs' not in output_params:
+    return
+  d = output_params['num_outputs']
+  output_params['num_outputs'] = _make_divisible(d * multiplier, divisible_by,
+                                                 min_depth)
+
+
+_Op = collections.namedtuple('Op', ['op', 'params', 'multiplier_func'])
+
+
+def op(opfunc, **params):
+  multiplier = params.pop('multiplier_transorm', depth_multiplier)
+  return _Op(opfunc, params=params, multiplier_func=multiplier)
+
+
+@slim.add_arg_scope
+def mobilenet_base(  # pylint: disable=invalid-name
+    inputs,
+    conv_defs,
+    multiplier=1.0,
+    final_endpoint=None,
+    output_stride=None,
+    use_explicit_padding=False,
+    scope=None,
+    is_training=False):
+  """Mobilenet base network.
+
+  Constructs a network from inputs to the given final endpoint. By default
+  the network is constructed in inference mode. To create network
+  in training mode use:
+
+  with slim.arg_scope(mobilenet.training_scope()):
+     logits, endpoints = mobilenet_base(...)
+
+  Args:
+    inputs: a tensor of shape [batch_size, height, width, channels].
+    conv_defs: A list of op(...) layers specifying the net architecture.
+    multiplier: Float multiplier for the depth (number of channels)
+      for all convolution ops. The value must be greater than zero. Typical
+      usage will be to set this value in (0, 1) to reduce the number of
+      parameters or computation cost of the model.
+    final_endpoint: The name of last layer, for early termination for
+    for V1-based networks: last layer is "layer_14", for V2: "layer_20"
+    output_stride: An integer that specifies the requested ratio of input to
+      output spatial resolution. If not None, then we invoke atrous convolution
+      if necessary to prevent the network from reducing the spatial resolution
+      of the activation maps. Allowed values are 1 or any even number, excluding
+      zero. Typical values are 8 (accurate fully convolutional mode), 16
+      (fast fully convolutional mode), and 32 (classification mode).
+
+      NOTE- output_stride relies on all consequent operators to support dilated
+      operators via "rate" parameter. This might require wrapping non-conv
+      operators to operate properly.
+
+    use_explicit_padding: Use 'VALID' padding for convolutions, but prepad
+      inputs so that the output dimensions are the same as if 'SAME' padding
+      were used.
+    scope: optional variable scope.
+    is_training: How to setup batch_norm and other ops. Note: most of the time
+      this does not need be set directly. Use mobilenet.training_scope() to set
+      up training instead. This parameter is here for backward compatibility
+      only. It is safe to set it to the value matching
+      training_scope(is_training=...). It is also safe to explicitly set
+      it to False, even if there is outer training_scope set to to training.
+      (The network will be built in inference mode).
+  Returns:
+    tensor_out: output tensor.
+    end_points: a set of activations for external use, for example summaries or
+                losses.
+
+  Raises:
+    ValueError: depth_multiplier <= 0, or the target output_stride is not
+                allowed.
+  """
+  if multiplier <= 0:
+    raise ValueError('multiplier is not greater than zero.')
+
+  # Set conv defs defaults and overrides.
+  conv_defs_defaults = conv_defs.get('defaults', {})
+  conv_defs_overrides = conv_defs.get('overrides', {})
+  if use_explicit_padding:
+    conv_defs_overrides = copy.deepcopy(conv_defs_overrides)
+    conv_defs_overrides[
+        (slim.conv2d, slim.separable_conv2d)] = {'padding': 'VALID'}
+
+  if output_stride is not None:
+    if output_stride == 0 or (output_stride > 1 and output_stride % 2):
+      raise ValueError('Output stride must be None, 1 or a multiple of 2.')
+
+  # a) Set the tensorflow scope
+  # b) set padding to default: note we might consider removing this
+  # since it is also set by mobilenet_scope
+  # c) set all defaults
+  # d) set all extra overrides.
+  with _scope_all(scope, default_scope='Mobilenet'), \
+      slim.arg_scope([slim.batch_norm], is_training=is_training), \
+      _set_arg_scope_defaults(conv_defs_defaults), \
+      _set_arg_scope_defaults(conv_defs_overrides):
+    # The current_stride variable keeps track of the output stride of the
+    # activations, i.e., the running product of convolution strides up to the
+    # current network layer. This allows us to invoke atrous convolution
+    # whenever applying the next convolution would result in the activations
+    # having output stride larger than the target output_stride.
+    current_stride = 1
+
+    # The atrous convolution rate parameter.
+    rate = 1
+
+    net = inputs
+    # Insert default parameters before the base scope which includes
+    # any custom overrides set in mobilenet.
+    end_points = {}
+    scopes = {}
+    for i, opdef in enumerate(conv_defs['spec']):
+      params = dict(opdef.params)
+      opdef.multiplier_func(params, multiplier)
+      stride = params.get('stride', 1)
+      if output_stride is not None and current_stride == output_stride:
+        # If we have reached the target output_stride, then we need to employ
+        # atrous convolution with stride=1 and multiply the atrous rate by the
+        # current unit's stride for use in subsequent layers.
+        layer_stride = 1
+        layer_rate = rate
+        rate *= stride
+      else:
+        layer_stride = stride
+        layer_rate = 1
+        current_stride *= stride
+      # Update params.
+      params['stride'] = layer_stride
+      # Only insert rate to params if rate > 1.
+      if layer_rate > 1:
+        params['rate'] = layer_rate
+      # Set padding
+      if use_explicit_padding:
+        if 'kernel_size' in params:
+          net = _fixed_padding(net, params['kernel_size'], layer_rate)
+        else:
+          params['use_explicit_padding'] = True
+
+      end_point = 'layer_%d' % (i + 1)
+      try:
+        net = opdef.op(net, **params)
+      except Exception:
+        print('Failed to create op %i: %r params: %r' % (i, opdef, params))
+        raise
+      end_points[end_point] = net
+      scope = os.path.dirname(net.name)
+      scopes[scope] = end_point
+      if final_endpoint is not None and end_point == final_endpoint:
+        break
+
+    # Add all tensors that end with 'output' to
+    # endpoints
+    for t in net.graph.get_operations():
+      scope = os.path.dirname(t.name)
+      bn = os.path.basename(t.name)
+      if scope in scopes and t.name.endswith('output'):
+        end_points[scopes[scope] + '/' + bn] = t.outputs[0]
+    return net, end_points
+
+
+@contextlib.contextmanager
+def _scope_all(scope, default_scope=None):
+  with tf.variable_scope(scope, default_name=default_scope) as s,\
+       tf.name_scope(s.original_name_scope):
+    yield s
+
+
+@slim.add_arg_scope
+def mobilenet(inputs,
+              num_classes=1001,
+              prediction_fn=slim.softmax,
+              reuse=None,
+              scope='Mobilenet',
+              base_only=False,
+              **mobilenet_args):
+  """Mobilenet model for classification, supports both V1 and V2.
+
+  Note: default mode is inference, use mobilenet.training_scope to create
+  training network.
+
+
+  Args:
+    inputs: a tensor of shape [batch_size, height, width, channels].
+    num_classes: number of predicted classes. If 0 or None, the logits layer
+      is omitted and the input features to the logits layer (before dropout)
+      are returned instead.
+    prediction_fn: a function to get predictions out of logits
+      (default softmax).
+    reuse: whether or not the network and its variables should be reused. To be
+      able to reuse 'scope' must be given.
+    scope: Optional variable_scope.
+    base_only: if True will only create the base of the network (no pooling
+    and no logits).
+    **mobilenet_args: passed to mobilenet_base verbatim.
+      - conv_defs: list of conv defs
+      - multiplier: Float multiplier for the depth (number of channels)
+      for all convolution ops. The value must be greater than zero. Typical
+      usage will be to set this value in (0, 1) to reduce the number of
+      parameters or computation cost of the model.
+      - output_stride: will ensure that the last layer has at most total stride.
+      If the architecture calls for more stride than that provided
+      (e.g. output_stride=16, but the architecture has 5 stride=2 operators),
+      it will replace output_stride with fractional convolutions using Atrous
+      Convolutions.
+
+  Returns:
+    logits: the pre-softmax activations, a tensor of size
+      [batch_size, num_classes]
+    end_points: a dictionary from components of the network to the corresponding
+      activation tensor.
+
+  Raises:
+    ValueError: Input rank is invalid.
+  """
+  is_training = mobilenet_args.get('is_training', False)
+  input_shape = inputs.get_shape().as_list()
+  if len(input_shape) != 4:
+    raise ValueError('Expected rank 4 input, was: %d' % len(input_shape))
+
+  with tf.variable_scope(scope, 'Mobilenet', reuse=reuse) as scope:
+    inputs = tf.identity(inputs, 'input')
+    net, end_points = mobilenet_base(inputs, scope=scope, **mobilenet_args)
+    if base_only:
+      return net, end_points
+
+    net = tf.identity(net, name='embedding')
+
+    with tf.variable_scope('Logits'):
+      net = global_pool(net)
+      end_points['global_pool'] = net
+      if not num_classes:
+        return net, end_points
+      net = slim.dropout(net, scope='Dropout', is_training=is_training)
+      # 1 x 1 x num_classes
+      # Note: legacy scope name.
+      logits = slim.conv2d(
+          net,
+          num_classes, [1, 1],
+          activation_fn=None,
+          normalizer_fn=None,
+          biases_initializer=tf.zeros_initializer(),
+          scope='Conv2d_1c_1x1')
+
+      logits = tf.squeeze(logits, [1, 2])
+
+      logits = tf.identity(logits, name='output')
+    end_points['Logits'] = logits
+    if prediction_fn:
+      end_points['Predictions'] = prediction_fn(logits, 'Predictions')
+  return logits, end_points
+
+
+def global_pool(input_tensor, pool_op=tf.nn.avg_pool):
+  """Applies avg pool to produce 1x1 output.
+
+  NOTE: This function is funcitonally equivalenet to reduce_mean, but it has
+  baked in average pool which has better support across hardware.
+
+  Args:
+    input_tensor: input tensor
+    pool_op: pooling op (avg pool is default)
+  Returns:
+    a tensor batch_size x 1 x 1 x depth.
+  """
+  shape = input_tensor.get_shape().as_list()
+  if shape[1] is None or shape[2] is None:
+    kernel_size = tf.convert_to_tensor(
+        [1, tf.shape(input_tensor)[1],
+         tf.shape(input_tensor)[2], 1])
+  else:
+    kernel_size = [1, shape[1], shape[2], 1]
+  output = pool_op(
+      input_tensor, ksize=kernel_size, strides=[1, 1, 1, 1], padding='VALID')
+  # Recover output shape, for unknown shape.
+  output.set_shape([None, 1, 1, None])
+  return output
+
+
+def training_scope(is_training=True,
+                   weight_decay=0.00004,
+                   stddev=0.09,
+                   dropout_keep_prob=0.8,
+                   bn_decay=0.997):
+  """Defines Mobilenet training scope.
+
+  Usage:
+     with tf.contrib.slim.arg_scope(mobilenet.training_scope()):
+       logits, endpoints = mobilenet_v2.mobilenet(input_tensor)
+
+     # the network created will be trainble with dropout/batch norm
+     # initialized appropriately.
+  Args:
+    is_training: if set to False this will ensure that all customizations are
+    set to non-training mode. This might be helpful for code that is reused
+    across both training/evaluation, but most of the time training_scope with
+    value False is not needed.
+
+    weight_decay: The weight decay to use for regularizing the model.
+    stddev: Standard deviation for initialization, if negative uses xavier.
+    dropout_keep_prob: dropout keep probability
+    bn_decay: decay for the batch norm moving averages.
+
+  Returns:
+    An argument scope to use via arg_scope.
+  """
+  # Note: do not introduce parameters that would change the inference
+  # model here (for example whether to use bias), modify conv_def instead.
+  batch_norm_params = {
+      'is_training': is_training,
+      'decay': bn_decay,
+  }
+
+  if stddev < 0:
+    weight_intitializer = slim.initializers.xavier_initializer()
+  else:
+    weight_intitializer = tf.truncated_normal_initializer(stddev=stddev)
+
+  # Set weight_decay for weights in Conv and FC layers.
+  with slim.arg_scope(
+      [slim.conv2d, slim.fully_connected, slim.separable_conv2d],
+      weights_initializer=weight_intitializer,
+      normalizer_fn=slim.batch_norm), \
+      slim.arg_scope([mobilenet_base, mobilenet], is_training=is_training),\
+      slim.arg_scope([slim.batch_norm], **batch_norm_params), \
+      slim.arg_scope([slim.dropout], is_training=is_training,
+                     keep_prob=dropout_keep_prob), \
+      slim.arg_scope([slim.conv2d], \
+                     weights_regularizer=slim.l2_regularizer(weight_decay)), \
+      slim.arg_scope([slim.separable_conv2d], weights_regularizer=None) as s:
+    return s
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/mobilenet/mobilenet_v2.py b/example-apps/PDD/pcb-defect-detection/libs/networks/mobilenet/mobilenet_v2.py
new file mode 100755
index 0000000..84300cd
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/mobilenet/mobilenet_v2.py
@@ -0,0 +1,188 @@
+# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Implementation of Mobilenet V2.
+
+Architecture: https://arxiv.org/abs/1801.04381
+
+The base model gives 72.2% accuracy on ImageNet, with 300MMadds,
+3.4 M parameters.
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import copy
+
+import tensorflow as tf
+
+from libs.networks.mobilenet import conv_blocks as ops
+from libs.networks.mobilenet import mobilenet as lib
+
+slim = tf.contrib.slim
+op = lib.op
+
+expand_input = ops.expand_input_by_factor
+
+# pyformat: disable
+# Architecture: https://arxiv.org/abs/1801.04381
+V2_DEF = dict(
+    defaults={
+        # Note: these parameters of batch norm affect the architecture
+        # that's why they are here and not in training_scope.
+        (slim.batch_norm,): {'center': True, 'scale': True},
+        (slim.conv2d, slim.fully_connected, slim.separable_conv2d): {
+            'normalizer_fn': slim.batch_norm, 'activation_fn': tf.nn.relu6
+        },
+        (ops.expanded_conv,): {
+            'expansion_size': expand_input(6),
+            'split_expansion': 1,
+            'normalizer_fn': slim.batch_norm,
+            'residual': True
+        },
+        (slim.conv2d, slim.separable_conv2d): {'padding': 'SAME'}
+    },
+    spec=[
+        op(slim.conv2d, stride=2, num_outputs=32, kernel_size=[3, 3]),
+        op(ops.expanded_conv,
+           expansion_size=expand_input(1, divisible_by=1),
+           num_outputs=16),
+        op(ops.expanded_conv, stride=2, num_outputs=24),
+        op(ops.expanded_conv, stride=1, num_outputs=24),
+        op(ops.expanded_conv, stride=2, num_outputs=32),
+        op(ops.expanded_conv, stride=1, num_outputs=32),
+        op(ops.expanded_conv, stride=1, num_outputs=32),
+        op(ops.expanded_conv, stride=2, num_outputs=64),
+        op(ops.expanded_conv, stride=1, num_outputs=64),
+        op(ops.expanded_conv, stride=1, num_outputs=64),
+        op(ops.expanded_conv, stride=1, num_outputs=64),
+        op(ops.expanded_conv, stride=1, num_outputs=96),
+        op(ops.expanded_conv, stride=1, num_outputs=96),
+        op(ops.expanded_conv, stride=1, num_outputs=96),
+        op(ops.expanded_conv, stride=2, num_outputs=160),
+        op(ops.expanded_conv, stride=1, num_outputs=160),
+        op(ops.expanded_conv, stride=1, num_outputs=160),
+        op(ops.expanded_conv, stride=1, num_outputs=320),
+        op(slim.conv2d, stride=1, kernel_size=[1, 1], num_outputs=1280)
+    ],
+)
+# pyformat: enable
+
+
+@slim.add_arg_scope
+def mobilenet(input_tensor,
+              num_classes=1001,
+              depth_multiplier=1.0,
+              scope='MobilenetV2',
+              conv_defs=None,
+              finegrain_classification_mode=False,
+              min_depth=None,
+              divisible_by=None,
+              **kwargs):
+  """Creates mobilenet V2 network.
+
+  Inference mode is created by default. To create training use training_scope
+  below.
+
+  with tf.contrib.slim.arg_scope(mobilenet_v2.training_scope()):
+     logits, endpoints = mobilenet_v2.mobilenet(input_tensor)
+
+  Args:
+    input_tensor: The input tensor
+    num_classes: number of classes
+    depth_multiplier: The multiplier applied to scale number of
+    channels in each layer. Note: this is called depth multiplier in the
+    paper but the name is kept for consistency with slim's model builder.
+    scope: Scope of the operator
+    conv_defs: Allows to override default conv def.
+    finegrain_classification_mode: When set to True, the model
+    will keep the last layer large even for small multipliers. Following
+    https://arxiv.org/abs/1801.04381
+    suggests that it improves performance for ImageNet-type of problems.
+      *Note* ignored if final_endpoint makes the builder exit earlier.
+    min_depth: If provided, will ensure that all layers will have that
+    many channels after application of depth multiplier.
+    divisible_by: If provided will ensure that all layers # channels
+    will be divisible by this number.
+    **kwargs: passed directly to mobilenet.mobilenet:
+      prediciton_fn- what prediction function to use.
+      reuse-: whether to reuse variables (if reuse set to true, scope
+      must be given).
+  Returns:
+    logits/endpoints pair
+
+  Raises:
+    ValueError: On invalid arguments
+  """
+  if conv_defs is None:
+    conv_defs = V2_DEF
+  if 'multiplier' in kwargs:
+    raise ValueError('mobilenetv2 doesn\'t support generic '
+                     'multiplier parameter use "depth_multiplier" instead.')
+  if finegrain_classification_mode:
+    conv_defs = copy.deepcopy(conv_defs)
+    if depth_multiplier < 1:
+      conv_defs['spec'][-1].params['num_outputs'] /= depth_multiplier
+
+  depth_args = {}
+  # NB: do not set depth_args unless they are provided to avoid overriding
+  # whatever default depth_multiplier might have thanks to arg_scope.
+  if min_depth is not None:
+    depth_args['min_depth'] = min_depth
+  if divisible_by is not None:
+    depth_args['divisible_by'] = divisible_by
+
+  with slim.arg_scope((lib.depth_multiplier,), **depth_args):
+    return lib.mobilenet(
+        input_tensor,
+        num_classes=num_classes,
+        conv_defs=conv_defs,
+        scope=scope,
+        multiplier=depth_multiplier,
+        **kwargs)
+
+
+@slim.add_arg_scope
+def mobilenet_base(input_tensor, depth_multiplier=1.0, **kwargs):
+  """Creates base of the mobilenet (no pooling and no logits) ."""
+  return mobilenet(input_tensor,
+                   depth_multiplier=depth_multiplier,
+                   base_only=True, **kwargs)
+
+
+def training_scope(**kwargs):
+  """Defines MobilenetV2 training scope.
+
+  Usage:
+     with tf.contrib.slim.arg_scope(mobilenet_v2.training_scope()):
+       logits, endpoints = mobilenet_v2.mobilenet(input_tensor)
+
+  with slim.
+
+  Args:
+    **kwargs: Passed to mobilenet.training_scope. The following parameters
+    are supported:
+      weight_decay- The weight decay to use for regularizing the model.
+      stddev-  Standard deviation for initialization, if negative uses xavier.
+      dropout_keep_prob- dropout keep probability
+      bn_decay- decay for the batch norm moving averages.
+
+  Returns:
+    An `arg_scope` to use for the mobilenet v2 model.
+  """
+  return lib.training_scope(**kwargs)
+
+
+__all__ = ['training_scope', 'mobilenet_base', 'mobilenet', 'V2_DEF']
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/mobilenet/mobilenet_v2_test.py b/example-apps/PDD/pcb-defect-detection/libs/networks/mobilenet/mobilenet_v2_test.py
new file mode 100755
index 0000000..40e48fa
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/mobilenet/mobilenet_v2_test.py
@@ -0,0 +1,176 @@
+# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for mobilenet_v2."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+import copy
+import tensorflow as tf
+from nets.mobilenet import conv_blocks as ops
+from nets.mobilenet import mobilenet
+from nets.mobilenet import mobilenet_v2
+
+
+slim = tf.contrib.slim
+
+
+def find_ops(optype):
+  """Find ops of a given type in graphdef or a graph.
+
+  Args:
+    optype: operation type (e.g. Conv2D)
+  Returns:
+     List of operations.
+  """
+  gd = tf.get_default_graph()
+  return [var for var in gd.get_operations() if var.type == optype]
+
+
+class MobilenetV2Test(tf.test.TestCase):
+
+  def setUp(self):
+    tf.reset_default_graph()
+
+  def testCreation(self):
+    spec = dict(mobilenet_v2.V2_DEF)
+    _, ep = mobilenet.mobilenet(
+        tf.placeholder(tf.float32, (10, 224, 224, 16)), conv_defs=spec)
+    num_convs = len(find_ops('Conv2D'))
+
+    # This is mostly a sanity test. No deep reason for these particular
+    # constants.
+    #
+    # All but first 2 and last one have  two convolutions, and there is one
+    # extra conv that is not in the spec. (logits)
+    self.assertEqual(num_convs, len(spec['spec']) * 2 - 2)
+    # Check that depthwise are exposed.
+    for i in range(2, 17):
+      self.assertIn('layer_%d/depthwise_output' % i, ep)
+
+  def testCreationNoClasses(self):
+    spec = copy.deepcopy(mobilenet_v2.V2_DEF)
+    net, ep = mobilenet.mobilenet(
+        tf.placeholder(tf.float32, (10, 224, 224, 16)), conv_defs=spec,
+        num_classes=None)
+    self.assertIs(net, ep['global_pool'])
+
+  def testImageSizes(self):
+    for input_size, output_size in [(224, 7), (192, 6), (160, 5),
+                                    (128, 4), (96, 3)]:
+      tf.reset_default_graph()
+      _, ep = mobilenet_v2.mobilenet(
+          tf.placeholder(tf.float32, (10, input_size, input_size, 3)))
+
+      self.assertEqual(ep['layer_18/output'].get_shape().as_list()[1:3],
+                       [output_size] * 2)
+
+  def testWithSplits(self):
+    spec = copy.deepcopy(mobilenet_v2.V2_DEF)
+    spec['overrides'] = {
+        (ops.expanded_conv,): dict(split_expansion=2),
+    }
+    _, _ = mobilenet.mobilenet(
+        tf.placeholder(tf.float32, (10, 224, 224, 16)), conv_defs=spec)
+    num_convs = len(find_ops('Conv2D'))
+    # All but 3 op has 3 conv operatore, the remainign 3 have one
+    # and there is one unaccounted.
+    self.assertEqual(num_convs, len(spec['spec']) * 3 - 5)
+
+  def testWithOutputStride8(self):
+    out, _ = mobilenet.mobilenet_base(
+        tf.placeholder(tf.float32, (10, 224, 224, 16)),
+        conv_defs=mobilenet_v2.V2_DEF,
+        output_stride=8,
+        scope='MobilenetV2')
+    self.assertEqual(out.get_shape().as_list()[1:3], [28, 28])
+
+  def testDivisibleBy(self):
+    tf.reset_default_graph()
+    mobilenet_v2.mobilenet(
+        tf.placeholder(tf.float32, (10, 224, 224, 16)),
+        conv_defs=mobilenet_v2.V2_DEF,
+        divisible_by=16,
+        min_depth=32)
+    s = [op.outputs[0].get_shape().as_list()[-1] for op in find_ops('Conv2D')]
+    s = set(s)
+    self.assertSameElements([32, 64, 96, 160, 192, 320, 384, 576, 960, 1280,
+                             1001], s)
+
+  def testDivisibleByWithArgScope(self):
+    tf.reset_default_graph()
+    # Verifies that depth_multiplier arg scope actually works
+    # if no default min_depth is provided.
+    with slim.arg_scope((mobilenet.depth_multiplier,), min_depth=32):
+      mobilenet_v2.mobilenet(
+          tf.placeholder(tf.float32, (10, 224, 224, 2)),
+          conv_defs=mobilenet_v2.V2_DEF, depth_multiplier=0.1)
+      s = [op.outputs[0].get_shape().as_list()[-1] for op in find_ops('Conv2D')]
+      s = set(s)
+      self.assertSameElements(s, [32, 192, 128, 1001])
+
+  def testFineGrained(self):
+    tf.reset_default_graph()
+    # Verifies that depth_multiplier arg scope actually works
+    # if no default min_depth is provided.
+
+    mobilenet_v2.mobilenet(
+        tf.placeholder(tf.float32, (10, 224, 224, 2)),
+        conv_defs=mobilenet_v2.V2_DEF, depth_multiplier=0.01,
+        finegrain_classification_mode=True)
+    s = [op.outputs[0].get_shape().as_list()[-1] for op in find_ops('Conv2D')]
+    s = set(s)
+    # All convolutions will be 8->48, except for the last one.
+    self.assertSameElements(s, [8, 48, 1001, 1280])
+
+  def testMobilenetBase(self):
+    tf.reset_default_graph()
+    # Verifies that mobilenet_base returns pre-pooling layer.
+    with slim.arg_scope((mobilenet.depth_multiplier,), min_depth=32):
+      net, _ = mobilenet_v2.mobilenet_base(
+          tf.placeholder(tf.float32, (10, 224, 224, 16)),
+          conv_defs=mobilenet_v2.V2_DEF, depth_multiplier=0.1)
+      self.assertEqual(net.get_shape().as_list(), [10, 7, 7, 128])
+
+  def testWithOutputStride16(self):
+    tf.reset_default_graph()
+    out, _ = mobilenet.mobilenet_base(
+        tf.placeholder(tf.float32, (10, 224, 224, 16)),
+        conv_defs=mobilenet_v2.V2_DEF,
+        output_stride=16)
+    self.assertEqual(out.get_shape().as_list()[1:3], [14, 14])
+
+  def testWithOutputStride8AndExplicitPadding(self):
+    tf.reset_default_graph()
+    out, _ = mobilenet.mobilenet_base(
+        tf.placeholder(tf.float32, (10, 224, 224, 16)),
+        conv_defs=mobilenet_v2.V2_DEF,
+        output_stride=8,
+        use_explicit_padding=True,
+        scope='MobilenetV2')
+    self.assertEqual(out.get_shape().as_list()[1:3], [28, 28])
+
+  def testWithOutputStride16AndExplicitPadding(self):
+    tf.reset_default_graph()
+    out, _ = mobilenet.mobilenet_base(
+        tf.placeholder(tf.float32, (10, 224, 224, 16)),
+        conv_defs=mobilenet_v2.V2_DEF,
+        output_stride=16,
+        use_explicit_padding=True)
+    self.assertEqual(out.get_shape().as_list()[1:3], [14, 14])
+
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/mobilenet_v2.py b/example-apps/PDD/pcb-defect-detection/libs/networks/mobilenet_v2.py
new file mode 100755
index 0000000..eced27c
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/mobilenet_v2.py
@@ -0,0 +1,126 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import, print_function, division
+import tensorflow.contrib.slim as slim
+import tensorflow as tf
+
+from libs.networks.mobilenet import mobilenet_v2
+from libs.networks.mobilenet.mobilenet import training_scope
+from libs.networks.mobilenet.mobilenet_v2 import op
+from libs.networks.mobilenet.mobilenet_v2 import ops
+expand_input = ops.expand_input_by_factor
+
+V2_BASE_DEF = dict(
+    defaults={
+        # Note: these parameters of batch norm affect the architecture
+        # that's why they are here and not in training_scope.
+        (slim.batch_norm,): {'center': True, 'scale': True},
+        (slim.conv2d, slim.fully_connected, slim.separable_conv2d): {
+            'normalizer_fn': slim.batch_norm, 'activation_fn': tf.nn.relu6
+        },
+        (ops.expanded_conv,): {
+            'expansion_size': expand_input(6),
+            'split_expansion': 1,
+            'normalizer_fn': slim.batch_norm,
+            'residual': True
+        },
+        (slim.conv2d, slim.separable_conv2d): {'padding': 'SAME'}
+    },
+    spec=[
+        op(slim.conv2d, stride=2, num_outputs=32, kernel_size=[3, 3]),
+        op(ops.expanded_conv,
+           expansion_size=expand_input(1, divisible_by=1),
+           num_outputs=16, scope='expanded_conv'),
+        op(ops.expanded_conv, stride=2, num_outputs=24, scope='expanded_conv_1'),
+        op(ops.expanded_conv, stride=1, num_outputs=24, scope='expanded_conv_2'),
+        op(ops.expanded_conv, stride=2, num_outputs=32, scope='expanded_conv_3'),
+        op(ops.expanded_conv, stride=1, num_outputs=32, scope='expanded_conv_4'),
+        op(ops.expanded_conv, stride=1, num_outputs=32, scope='expanded_conv_5'),
+        op(ops.expanded_conv, stride=2, num_outputs=64, scope='expanded_conv_6'),
+        op(ops.expanded_conv, stride=1, num_outputs=64, scope='expanded_conv_7'),
+        op(ops.expanded_conv, stride=1, num_outputs=64, scope='expanded_conv_8'),
+        op(ops.expanded_conv, stride=1, num_outputs=64, scope='expanded_conv_9'),
+        op(ops.expanded_conv, stride=1, num_outputs=96, scope='expanded_conv_10'),
+        op(ops.expanded_conv, stride=1, num_outputs=96, scope='expanded_conv_11'),
+        op(ops.expanded_conv, stride=1, num_outputs=96, scope='expanded_conv_12')
+    ],
+)
+
+
+V2_HEAD_DEF = dict(
+    defaults={
+        # Note: these parameters of batch norm affect the architecture
+        # that's why they are here and not in training_scope.
+        (slim.batch_norm,): {'center': True, 'scale': True},
+        (slim.conv2d, slim.fully_connected, slim.separable_conv2d): {
+            'normalizer_fn': slim.batch_norm, 'activation_fn': tf.nn.relu6
+        },
+        (ops.expanded_conv,): {
+            'expansion_size': expand_input(6),
+            'split_expansion': 1,
+            'normalizer_fn': slim.batch_norm,
+            'residual': True
+        },
+        (slim.conv2d, slim.separable_conv2d): {'padding': 'SAME'}
+    },
+    spec=[
+        op(ops.expanded_conv, stride=2, num_outputs=160, scope='expanded_conv_13'),
+        op(ops.expanded_conv, stride=1, num_outputs=160, scope='expanded_conv_14'),
+        op(ops.expanded_conv, stride=1, num_outputs=160, scope='expanded_conv_15'),
+        op(ops.expanded_conv, stride=1, num_outputs=320, scope='expanded_conv_16'),
+        op(slim.conv2d, stride=1, kernel_size=[1, 1], num_outputs=1280, scope='Conv_1')
+    ],
+)
+def mobilenetv2_scope(is_training=True,
+                      trainable=True,
+                      weight_decay=0.00004,
+                      stddev=0.09,
+                      dropout_keep_prob=0.8,
+                      bn_decay=0.997):
+  """Defines Mobilenet training scope.
+  In default. We do not use BN
+
+  ReWrite the scope.
+  """
+  batch_norm_params = {
+      'is_training': False,
+      'trainable': False,
+      'decay': bn_decay,
+  }
+  with slim.arg_scope(training_scope(is_training=is_training, weight_decay=weight_decay)):
+      with slim.arg_scope([slim.conv2d, slim.fully_connected, slim.separable_conv2d],
+                          trainable=trainable):
+          with slim.arg_scope([slim.batch_norm], **batch_norm_params) as sc:
+              return sc
+
+
+
+def mobilenetv2_base(img_batch, is_training=True):
+
+    with slim.arg_scope(mobilenetv2_scope(is_training=is_training, trainable=True)):
+
+        feature_to_crop, endpoints = mobilenet_v2.mobilenet_base(input_tensor=img_batch,
+                                                      num_classes=None,
+                                                      is_training=False,
+                                                      depth_multiplier=1.0,
+                                                      scope='MobilenetV2',
+                                                      conv_defs=V2_BASE_DEF,
+                                                      finegrain_classification_mode=False)
+
+        # feature_to_crop = tf.Print(feature_to_crop, [tf.shape(feature_to_crop)], summarize=10, message='rpn_shape')
+        return feature_to_crop
+
+
+def mobilenetv2_head(inputs, is_training=True):
+    with slim.arg_scope(mobilenetv2_scope(is_training=is_training, trainable=True)):
+        net, _ = mobilenet_v2.mobilenet(input_tensor=inputs,
+                                        num_classes=None,
+                                        is_training=False,
+                                        depth_multiplier=1.0,
+                                        scope='MobilenetV2',
+                                        conv_defs=V2_HEAD_DEF,
+                                        finegrain_classification_mode=False)
+
+        net = tf.squeeze(net, [1, 2])
+
+        return net
\ No newline at end of file
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/resnet.py b/example-apps/PDD/pcb-defect-detection/libs/networks/resnet.py
new file mode 100755
index 0000000..4aaa9b9
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/resnet.py
@@ -0,0 +1,268 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import, print_function, division
+
+
+import tensorflow as tf
+import tensorflow.contrib.slim as slim
+from libs.configs import cfgs
+from tensorflow.contrib.slim.nets import resnet_v1
+from tensorflow.contrib.slim.nets import resnet_utils
+from tensorflow.contrib.slim.python.slim.nets.resnet_v1 import resnet_v1_block
+import tfplot as tfp
+
+
+def resnet_arg_scope(
+        is_training=True, weight_decay=cfgs.WEIGHT_DECAY, batch_norm_decay=0.997,
+        batch_norm_epsilon=1e-5, batch_norm_scale=True):
+    '''
+
+    In Default, we do not use BN to train resnet, since batch_size is too small.
+    So is_training is False and trainable is False in the batch_norm params.
+
+    '''
+    batch_norm_params = {
+        'is_training': False, 'decay': batch_norm_decay,
+        'epsilon': batch_norm_epsilon, 'scale': batch_norm_scale,
+        'trainable': False,
+        'updates_collections': tf.GraphKeys.UPDATE_OPS
+    }
+
+    with slim.arg_scope(
+            [slim.conv2d],
+            weights_regularizer=slim.l2_regularizer(weight_decay),
+            weights_initializer=slim.variance_scaling_initializer(),
+            trainable=is_training,
+            activation_fn=tf.nn.relu,
+            normalizer_fn=slim.batch_norm,
+            normalizer_params=batch_norm_params):
+        with slim.arg_scope([slim.batch_norm], **batch_norm_params) as arg_sc:
+            return arg_sc
+
+
+def fusion_two_layer(C_i, P_j, scope):
+    '''
+    i = j+1
+    :param C_i: shape is [1, h, w, c]
+    :param P_j: shape is [1, h/2, w/2, 256]
+    :return:
+    P_i
+    '''
+    with tf.variable_scope(scope):
+        level_name = scope.split('_')[1]
+        h, w = tf.shape(C_i)[1], tf.shape(C_i)[2]
+        upsample_p = tf.image.resize_bilinear(P_j,
+                                              size=[h, w],
+                                              name='up_sample_'+level_name)
+
+        reduce_dim_c = slim.conv2d(C_i,
+                                   num_outputs=256,
+                                   kernel_size=[1, 1], stride=1,
+                                   scope='reduce_dim_'+level_name)
+
+        add_f = 0.5*upsample_p + 0.5*reduce_dim_c
+
+        # P_i = slim.conv2d(add_f,
+        #                   num_outputs=256, kernel_size=[3, 3], stride=1,
+        #                   padding='SAME',
+        #                   scope='fusion_'+level_name)
+        return add_f
+
+
+def add_heatmap(feature_maps, name):
+    '''
+
+    :param feature_maps:[B, H, W, C]
+    :return:
+    '''
+
+    def figure_attention(activation):
+        fig, ax = tfp.subplots()
+        im = ax.imshow(activation, cmap='jet')
+        fig.colorbar(im)
+        return fig
+
+    heatmap = tf.reduce_sum(feature_maps, axis=-1)
+    heatmap = tf.squeeze(heatmap, axis=0)
+    tfp.summary.plot(name, figure_attention, [heatmap])
+
+
+def resnet_base(img_batch, scope_name, is_training=True):
+    '''
+    this code is derived from light-head rcnn.
+    https://github.com/zengarden/light_head_rcnn
+
+    It is convenient to freeze blocks. So we adapt this mode.
+    '''
+    if scope_name == 'resnet_v1_50':
+        middle_num_units = 6
+    elif scope_name == 'resnet_v1_101':
+        middle_num_units = 23
+    else:
+        raise NotImplementedError('We only support resnet_v1_50 or resnet_v1_101. Check your network name....yjr')
+
+    blocks = [resnet_v1_block('block1', base_depth=64, num_units=3, stride=2),
+              resnet_v1_block('block2', base_depth=128, num_units=4, stride=2),
+              resnet_v1_block('block3', base_depth=256, num_units=middle_num_units, stride=2),
+              resnet_v1_block('block4', base_depth=512, num_units=3, stride=1)]
+    # when use fpn . stride list is [1, 2, 2]
+
+    with slim.arg_scope(resnet_arg_scope(is_training=False)):
+        with tf.variable_scope(scope_name, scope_name):
+            # Do the first few layers manually, because 'SAME' padding can behave inconsistently
+            # for images of different sizes: sometimes 0, sometimes 1
+            net = resnet_utils.conv2d_same(
+                img_batch, 64, 7, stride=2, scope='conv1')
+            net = tf.pad(net, [[0, 0], [1, 1], [1, 1], [0, 0]])
+            net = slim.max_pool2d(
+                net, [3, 3], stride=2, padding='VALID', scope='pool1')
+
+    not_freezed = [False] * cfgs.FIXED_BLOCKS + (4-cfgs.FIXED_BLOCKS)*[True]
+    # Fixed_Blocks can be 1~3
+
+    with slim.arg_scope(resnet_arg_scope(is_training=(is_training and not_freezed[0]))):
+        C2, end_points_C2 = resnet_v1.resnet_v1(net,
+                                                blocks[0:1],
+                                                global_pool=False,
+                                                include_root_block=False,
+                                                scope=scope_name)
+
+    # C2 = tf.Print(C2, [tf.shape(C2)], summarize=10, message='C2_shape')
+    add_heatmap(C2, name='Layer2/C2_heat')
+
+    with slim.arg_scope(resnet_arg_scope(is_training=(is_training and not_freezed[1]))):
+        C3, end_points_C3 = resnet_v1.resnet_v1(C2,
+                                                blocks[1:2],
+                                                global_pool=False,
+                                                include_root_block=False,
+                                                scope=scope_name)
+
+    # C3 = tf.Print(C3, [tf.shape(C3)], summarize=10, message='C3_shape')
+    add_heatmap(C3, name='Layer3/C3_heat')
+    with slim.arg_scope(resnet_arg_scope(is_training=(is_training and not_freezed[2]))):
+        C4, end_points_C4 = resnet_v1.resnet_v1(C3,
+                                                blocks[2:3],
+                                                global_pool=False,
+                                                include_root_block=False,
+                                                scope=scope_name)
+
+    add_heatmap(C4, name='Layer4/C4_heat')
+
+    # C4 = tf.Print(C4, [tf.shape(C4)], summarize=10, message='C4_shape')
+    with slim.arg_scope(resnet_arg_scope(is_training=is_training)):
+        C5, end_points_C5 = resnet_v1.resnet_v1(C4,
+                                                blocks[3:4],
+                                                global_pool=False,
+                                                include_root_block=False,
+                                                scope=scope_name)
+    # C5 = tf.Print(C5, [tf.shape(C5)], summarize=10, message='C5_shape')
+    add_heatmap(C5, name='Layer5/C5_heat')
+
+    feature_dict = {'C2': end_points_C2['{}/block1/unit_2/bottleneck_v1'.format(scope_name)],
+                    'C3': end_points_C3['{}/block2/unit_3/bottleneck_v1'.format(scope_name)],
+                    'C4': end_points_C4['{}/block3/unit_{}/bottleneck_v1'.format(scope_name, middle_num_units - 1)],
+                    'C5': end_points_C5['{}/block4/unit_3/bottleneck_v1'.format(scope_name)],
+                    # 'C5': end_points_C5['{}/block4'.format(scope_name)],
+                    }
+
+    # feature_dict = {'C2': C2,
+    #                 'C3': C3,
+    #                 'C4': C4,
+    #                 'C5': C5}
+
+    pyramid_dict = {}
+    with tf.variable_scope('build_pyramid'):
+        with slim.arg_scope([slim.conv2d], weights_regularizer=slim.l2_regularizer(cfgs.WEIGHT_DECAY),
+                            activation_fn=None, normalizer_fn=None):
+
+            P5 = slim.conv2d(C5,
+                             num_outputs=256,
+                             kernel_size=[1, 1],
+                             stride=1, scope='build_P5')
+            if "P6" in cfgs.LEVLES:
+                P6 = slim.max_pool2d(P5, kernel_size=[1, 1], stride=2, scope='build_P6')
+                pyramid_dict['P6'] = P6
+
+            pyramid_dict['P5'] = P5
+
+            for level in range(4, 1, -1):  # build [P4, P3, P2]
+
+                pyramid_dict['P%d' % level] = fusion_two_layer(C_i=feature_dict["C%d" % level],
+                                                               P_j=pyramid_dict["P%d" % (level+1)],
+                                                               scope='build_P%d' % level)
+            for level in range(4, 1, -1):
+                pyramid_dict['P%d' % level] = slim.conv2d(pyramid_dict['P%d' % level],
+                                                          num_outputs=256, kernel_size=[3, 3], padding="SAME",
+                                                          stride=1, scope="fuse_P%d" % level)
+    for level in range(5, 1, -1):
+        add_heatmap(pyramid_dict['P%d' % level], name='Layer%d/P%d_heat' % (level, level))
+
+    # return [P2, P3, P4, P5, P6]
+    print("we are in Pyramid::-======>>>>")
+    print(cfgs.LEVLES)
+    print("base_anchor_size are: ", cfgs.BASE_ANCHOR_SIZE_LIST)
+    print(20 * "__")
+    return [pyramid_dict[level_name] for level_name in cfgs.LEVLES]
+    # return pyramid_dict  # return the dict. And get each level by key. But ensure the levels are consitant
+    # return list rather than dict, to avoid dict is unordered
+
+
+
+def restnet_head(inputs, is_training, scope_name):
+    '''
+
+    :param inputs: [minibatch_size, 7, 7, 256]
+    :param is_training:
+    :param scope_name:
+    :return:
+    '''
+
+    with tf.variable_scope('build_fc_layers'):
+
+        # fc1 = slim.conv2d(inputs=inputs,
+        #                   num_outputs=1024,
+        #                   kernel_size=[7, 7],
+        #                   padding='VALID',
+        #                   scope='fc1') # shape is [minibatch_size, 1, 1, 1024]
+        # fc1 = tf.squeeze(fc1, [1, 2], name='squeeze_fc1')
+
+        inputs = slim.flatten(inputs=inputs, scope='flatten_inputs')
+
+        fc1 = slim.fully_connected(inputs, num_outputs=1024, scope='fc1')
+
+        fc2 = slim.fully_connected(fc1, num_outputs=1024, scope='fc2')
+
+        # fc3 = slim.fully_connected(fc2, num_outputs=1024, scope='fc3')
+
+        # we add fc3 to increase the ability of fast-rcnn head
+        return fc2
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/__init__.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/__init__.py
new file mode 100755
index 0000000..8b13789
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/__init__.py
@@ -0,0 +1 @@
+
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/alexnet.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/alexnet.py
new file mode 100755
index 0000000..4e7e563
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/alexnet.py
@@ -0,0 +1,125 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Contains a model definition for AlexNet.
+
+This work was first described in:
+  ImageNet Classification with Deep Convolutional Neural Networks
+  Alex Krizhevsky, Ilya Sutskever and Geoffrey E. Hinton
+
+and later refined in:
+  One weird trick for parallelizing convolutional neural networks
+  Alex Krizhevsky, 2014
+
+Here we provide the implementation proposed in "One weird trick" and not
+"ImageNet Classification", as per the paper, the LRN layers have been removed.
+
+Usage:
+  with slim.arg_scope(alexnet.alexnet_v2_arg_scope()):
+    outputs, end_points = alexnet.alexnet_v2(inputs)
+
+@@alexnet_v2
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf
+
+slim = tf.contrib.slim
+trunc_normal = lambda stddev: tf.truncated_normal_initializer(0.0, stddev)
+
+
+def alexnet_v2_arg_scope(weight_decay=0.0005):
+  with slim.arg_scope([slim.conv2d, slim.fully_connected],
+                      activation_fn=tf.nn.relu,
+                      biases_initializer=tf.constant_initializer(0.1),
+                      weights_regularizer=slim.l2_regularizer(weight_decay)):
+    with slim.arg_scope([slim.conv2d], padding='SAME'):
+      with slim.arg_scope([slim.max_pool2d], padding='VALID') as arg_sc:
+        return arg_sc
+
+
+def alexnet_v2(inputs,
+               num_classes=1000,
+               is_training=True,
+               dropout_keep_prob=0.5,
+               spatial_squeeze=True,
+               scope='alexnet_v2'):
+  """AlexNet version 2.
+
+  Described in: http://arxiv.org/pdf/1404.5997v2.pdf
+  Parameters from:
+  github.com/akrizhevsky/cuda-convnet2/blob/master/layers/
+  layers-imagenet-1gpu.cfg
+
+  Note: All the fully_connected layers have been transformed to conv2d layers.
+        To use in classification mode, resize input to 224x224. To use in fully
+        convolutional mode, set spatial_squeeze to false.
+        The LRN layers have been removed and change the initializers from
+        random_normal_initializer to xavier_initializer.
+
+  Args:
+    inputs: a tensor of size [batch_size, height, width, channels].
+    num_classes: number of predicted classes.
+    is_training: whether or not the model is being trained.
+    dropout_keep_prob: the probability that activations are kept in the dropout
+      layers during training.
+    spatial_squeeze: whether or not should squeeze the spatial dimensions of the
+      outputs. Useful to remove unnecessary dimensions for classification.
+    scope: Optional scope for the variables.
+
+  Returns:
+    the last op containing the log predictions and end_points dict.
+  """
+  with tf.variable_scope(scope, 'alexnet_v2', [inputs]) as sc:
+    end_points_collection = sc.name + '_end_points'
+    # Collect outputs for conv2d, fully_connected and max_pool2d.
+    with slim.arg_scope([slim.conv2d, slim.fully_connected, slim.max_pool2d],
+                        outputs_collections=[end_points_collection]):
+      net = slim.conv2d(inputs, 64, [11, 11], 4, padding='VALID',
+                        scope='conv1')
+      net = slim.max_pool2d(net, [3, 3], 2, scope='pool1')
+      net = slim.conv2d(net, 192, [5, 5], scope='conv2')
+      net = slim.max_pool2d(net, [3, 3], 2, scope='pool2')
+      net = slim.conv2d(net, 384, [3, 3], scope='conv3')
+      net = slim.conv2d(net, 384, [3, 3], scope='conv4')
+      net = slim.conv2d(net, 256, [3, 3], scope='conv5')
+      net = slim.max_pool2d(net, [3, 3], 2, scope='pool5')
+
+      # Use conv2d instead of fully_connected layers.
+      with slim.arg_scope([slim.conv2d],
+                          weights_initializer=trunc_normal(0.005),
+                          biases_initializer=tf.constant_initializer(0.1)):
+        net = slim.conv2d(net, 4096, [5, 5], padding='VALID',
+                          scope='fc6')
+        net = slim.dropout(net, dropout_keep_prob, is_training=is_training,
+                           scope='dropout6')
+        net = slim.conv2d(net, 4096, [1, 1], scope='fc7')
+        net = slim.dropout(net, dropout_keep_prob, is_training=is_training,
+                           scope='dropout7')
+        net = slim.conv2d(net, num_classes, [1, 1],
+                          activation_fn=None,
+                          normalizer_fn=None,
+                          biases_initializer=tf.zeros_initializer(),
+                          scope='fc8')
+
+      # Convert end_points_collection into a end_point dict.
+      end_points = slim.utils.convert_collection_to_dict(end_points_collection)
+      if spatial_squeeze:
+        net = tf.squeeze(net, [1, 2], name='fc8/squeezed')
+        end_points[sc.name + '/fc8'] = net
+      return net, end_points
+alexnet_v2.default_image_size = 224
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/alexnet_test.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/alexnet_test.py
new file mode 100755
index 0000000..6fc9a05
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/alexnet_test.py
@@ -0,0 +1,145 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for slim.slim_nets.alexnet."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf
+
+from nets import alexnet
+
+slim = tf.contrib.slim
+
+
+class AlexnetV2Test(tf.test.TestCase):
+
+  def testBuild(self):
+    batch_size = 5
+    height, width = 224, 224
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, _ = alexnet.alexnet_v2(inputs, num_classes)
+      self.assertEquals(logits.op.name, 'alexnet_v2/fc8/squeezed')
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [batch_size, num_classes])
+
+  def testFullyConvolutional(self):
+    batch_size = 1
+    height, width = 300, 400
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, _ = alexnet.alexnet_v2(inputs, num_classes, spatial_squeeze=False)
+      self.assertEquals(logits.op.name, 'alexnet_v2/fc8/BiasAdd')
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [batch_size, 4, 7, num_classes])
+
+  def testEndPoints(self):
+    batch_size = 5
+    height, width = 224, 224
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      _, end_points = alexnet.alexnet_v2(inputs, num_classes)
+      expected_names = ['alexnet_v2/conv1',
+                        'alexnet_v2/pool1',
+                        'alexnet_v2/conv2',
+                        'alexnet_v2/pool2',
+                        'alexnet_v2/conv3',
+                        'alexnet_v2/conv4',
+                        'alexnet_v2/conv5',
+                        'alexnet_v2/pool5',
+                        'alexnet_v2/fc6',
+                        'alexnet_v2/fc7',
+                        'alexnet_v2/fc8'
+                       ]
+      self.assertSetEqual(set(end_points.keys()), set(expected_names))
+
+  def testModelVariables(self):
+    batch_size = 5
+    height, width = 224, 224
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      alexnet.alexnet_v2(inputs, num_classes)
+      expected_names = ['alexnet_v2/conv1/weights',
+                        'alexnet_v2/conv1/biases',
+                        'alexnet_v2/conv2/weights',
+                        'alexnet_v2/conv2/biases',
+                        'alexnet_v2/conv3/weights',
+                        'alexnet_v2/conv3/biases',
+                        'alexnet_v2/conv4/weights',
+                        'alexnet_v2/conv4/biases',
+                        'alexnet_v2/conv5/weights',
+                        'alexnet_v2/conv5/biases',
+                        'alexnet_v2/fc6/weights',
+                        'alexnet_v2/fc6/biases',
+                        'alexnet_v2/fc7/weights',
+                        'alexnet_v2/fc7/biases',
+                        'alexnet_v2/fc8/weights',
+                        'alexnet_v2/fc8/biases',
+                       ]
+      model_variables = [v.op.name for v in slim.get_model_variables()]
+      self.assertSetEqual(set(model_variables), set(expected_names))
+
+  def testEvaluation(self):
+    batch_size = 2
+    height, width = 224, 224
+    num_classes = 1000
+    with self.test_session():
+      eval_inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, _ = alexnet.alexnet_v2(eval_inputs, is_training=False)
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [batch_size, num_classes])
+      predictions = tf.argmax(logits, 1)
+      self.assertListEqual(predictions.get_shape().as_list(), [batch_size])
+
+  def testTrainEvalWithReuse(self):
+    train_batch_size = 2
+    eval_batch_size = 1
+    train_height, train_width = 224, 224
+    eval_height, eval_width = 300, 400
+    num_classes = 1000
+    with self.test_session():
+      train_inputs = tf.random_uniform(
+          (train_batch_size, train_height, train_width, 3))
+      logits, _ = alexnet.alexnet_v2(train_inputs)
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [train_batch_size, num_classes])
+      tf.get_variable_scope().reuse_variables()
+      eval_inputs = tf.random_uniform(
+          (eval_batch_size, eval_height, eval_width, 3))
+      logits, _ = alexnet.alexnet_v2(eval_inputs, is_training=False,
+                                     spatial_squeeze=False)
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [eval_batch_size, 4, 7, num_classes])
+      logits = tf.reduce_mean(logits, [1, 2])
+      predictions = tf.argmax(logits, 1)
+      self.assertEquals(predictions.get_shape().as_list(), [eval_batch_size])
+
+  def testForward(self):
+    batch_size = 1
+    height, width = 224, 224
+    with self.test_session() as sess:
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, _ = alexnet.alexnet_v2(inputs)
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(logits)
+      self.assertTrue(output.any())
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/cifarnet.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/cifarnet.py
new file mode 100755
index 0000000..44ca0fe
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/cifarnet.py
@@ -0,0 +1,112 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Contains a variant of the CIFAR-10 model definition."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf
+
+slim = tf.contrib.slim
+
+trunc_normal = lambda stddev: tf.truncated_normal_initializer(stddev=stddev)
+
+
+def cifarnet(images, num_classes=10, is_training=False,
+             dropout_keep_prob=0.5,
+             prediction_fn=slim.softmax,
+             scope='CifarNet'):
+  """Creates a variant of the CifarNet model.
+
+  Note that since the output is a set of 'logits', the values fall in the
+  interval of (-infinity, infinity). Consequently, to convert the outputs to a
+  probability distribution over the characters, one will need to convert them
+  using the softmax function:
+
+        logits = cifarnet.cifarnet(images, is_training=False)
+        probabilities = tf.nn.softmax(logits)
+        predictions = tf.argmax(logits, 1)
+
+  Args:
+    images: A batch of `Tensors` of size [batch_size, height, width, channels].
+    num_classes: the number of classes in the dataset.
+    is_training: specifies whether or not we're currently training the model.
+      This variable will determine the behaviour of the dropout layer.
+    dropout_keep_prob: the percentage of activation values that are retained.
+    prediction_fn: a function to get predictions out of logits.
+    scope: Optional variable_scope.
+
+  Returns:
+    logits: the pre-softmax activations, a tensor of size
+      [batch_size, `num_classes`]
+    end_points: a dictionary from components of the network to the corresponding
+      activation.
+  """
+  end_points = {}
+
+  with tf.variable_scope(scope, 'CifarNet', [images, num_classes]):
+    net = slim.conv2d(images, 64, [5, 5], scope='conv1')
+    end_points['conv1'] = net
+    net = slim.max_pool2d(net, [2, 2], 2, scope='pool1')
+    end_points['pool1'] = net
+    net = tf.nn.lrn(net, 4, bias=1.0, alpha=0.001/9.0, beta=0.75, name='norm1')
+    net = slim.conv2d(net, 64, [5, 5], scope='conv2')
+    end_points['conv2'] = net
+    net = tf.nn.lrn(net, 4, bias=1.0, alpha=0.001/9.0, beta=0.75, name='norm2')
+    net = slim.max_pool2d(net, [2, 2], 2, scope='pool2')
+    end_points['pool2'] = net
+    net = slim.flatten(net)
+    end_points['Flatten'] = net
+    net = slim.fully_connected(net, 384, scope='fc3')
+    end_points['fc3'] = net
+    net = slim.dropout(net, dropout_keep_prob, is_training=is_training,
+                       scope='dropout3')
+    net = slim.fully_connected(net, 192, scope='fc4')
+    end_points['fc4'] = net
+    logits = slim.fully_connected(net, num_classes,
+                                  biases_initializer=tf.zeros_initializer(),
+                                  weights_initializer=trunc_normal(1/192.0),
+                                  weights_regularizer=None,
+                                  activation_fn=None,
+                                  scope='logits')
+
+    end_points['Logits'] = logits
+    end_points['Predictions'] = prediction_fn(logits, scope='Predictions')
+
+  return logits, end_points
+cifarnet.default_image_size = 32
+
+
+def cifarnet_arg_scope(weight_decay=0.004):
+  """Defines the default cifarnet argument scope.
+
+  Args:
+    weight_decay: The weight decay to use for regularizing the model.
+
+  Returns:
+    An `arg_scope` to use for the inception v3 model.
+  """
+  with slim.arg_scope(
+      [slim.conv2d],
+      weights_initializer=tf.truncated_normal_initializer(stddev=5e-2),
+      activation_fn=tf.nn.relu):
+    with slim.arg_scope(
+        [slim.fully_connected],
+        biases_initializer=tf.constant_initializer(0.1),
+        weights_initializer=trunc_normal(0.04),
+        weights_regularizer=slim.l2_regularizer(weight_decay),
+        activation_fn=tf.nn.relu) as sc:
+      return sc
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception.py
new file mode 100755
index 0000000..b69cd2a
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception.py
@@ -0,0 +1,37 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Brings all inception models under one namespace."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+# pylint: disable=unused-import
+from nets.inception_resnet_v2 import inception_resnet_v2
+from nets.inception_resnet_v2 import inception_resnet_v2_arg_scope
+from nets.inception_resnet_v2 import inception_resnet_v2_base
+from nets.inception_v1 import inception_v1
+from nets.inception_v1 import inception_v1_arg_scope
+from nets.inception_v1 import inception_v1_base
+from nets.inception_v2 import inception_v2
+from nets.inception_v2 import inception_v2_arg_scope
+from nets.inception_v2 import inception_v2_base
+from nets.inception_v3 import inception_v3
+from nets.inception_v3 import inception_v3_arg_scope
+from nets.inception_v3 import inception_v3_base
+from nets.inception_v4 import inception_v4
+from nets.inception_v4 import inception_v4_arg_scope
+from nets.inception_v4 import inception_v4_base
+# pylint: enable=unused-import
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_resnet_v2.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_resnet_v2.py
new file mode 100755
index 0000000..ddd9392
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_resnet_v2.py
@@ -0,0 +1,359 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Contains the definition of the Inception Resnet V2 architecture.
+
+As described in http://arxiv.org/abs/1602.07261.
+
+  Inception-v4, Inception-ResNet and the Impact of Residual Connections
+    on Learning
+  Christian Szegedy, Sergey Ioffe, Vincent Vanhoucke, Alex Alemi
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+
+import tensorflow as tf
+
+slim = tf.contrib.slim
+
+
+def block35(net, scale=1.0, activation_fn=tf.nn.relu, scope=None, reuse=None):
+  """Builds the 35x35 resnet block."""
+  with tf.variable_scope(scope, 'Block35', [net], reuse=reuse):
+    with tf.variable_scope('Branch_0'):
+      tower_conv = slim.conv2d(net, 32, 1, scope='Conv2d_1x1')
+    with tf.variable_scope('Branch_1'):
+      tower_conv1_0 = slim.conv2d(net, 32, 1, scope='Conv2d_0a_1x1')
+      tower_conv1_1 = slim.conv2d(tower_conv1_0, 32, 3, scope='Conv2d_0b_3x3')
+    with tf.variable_scope('Branch_2'):
+      tower_conv2_0 = slim.conv2d(net, 32, 1, scope='Conv2d_0a_1x1')
+      tower_conv2_1 = slim.conv2d(tower_conv2_0, 48, 3, scope='Conv2d_0b_3x3')
+      tower_conv2_2 = slim.conv2d(tower_conv2_1, 64, 3, scope='Conv2d_0c_3x3')
+    mixed = tf.concat(axis=3, values=[tower_conv, tower_conv1_1, tower_conv2_2])
+    up = slim.conv2d(mixed, net.get_shape()[3], 1, normalizer_fn=None,
+                     activation_fn=None, scope='Conv2d_1x1')
+    net += scale * up
+    if activation_fn:
+      net = activation_fn(net)
+  return net
+
+
+def block17(net, scale=1.0, activation_fn=tf.nn.relu, scope=None, reuse=None):
+  """Builds the 17x17 resnet block."""
+  with tf.variable_scope(scope, 'Block17', [net], reuse=reuse):
+    with tf.variable_scope('Branch_0'):
+      tower_conv = slim.conv2d(net, 192, 1, scope='Conv2d_1x1')
+    with tf.variable_scope('Branch_1'):
+      tower_conv1_0 = slim.conv2d(net, 128, 1, scope='Conv2d_0a_1x1')
+      tower_conv1_1 = slim.conv2d(tower_conv1_0, 160, [1, 7],
+                                  scope='Conv2d_0b_1x7')
+      tower_conv1_2 = slim.conv2d(tower_conv1_1, 192, [7, 1],
+                                  scope='Conv2d_0c_7x1')
+    mixed = tf.concat(axis=3, values=[tower_conv, tower_conv1_2])
+    up = slim.conv2d(mixed, net.get_shape()[3], 1, normalizer_fn=None,
+                     activation_fn=None, scope='Conv2d_1x1')
+    net += scale * up
+    if activation_fn:
+      net = activation_fn(net)
+  return net
+
+
+def block8(net, scale=1.0, activation_fn=tf.nn.relu, scope=None, reuse=None):
+  """Builds the 8x8 resnet block."""
+  with tf.variable_scope(scope, 'Block8', [net], reuse=reuse):
+    with tf.variable_scope('Branch_0'):
+      tower_conv = slim.conv2d(net, 192, 1, scope='Conv2d_1x1')
+    with tf.variable_scope('Branch_1'):
+      tower_conv1_0 = slim.conv2d(net, 192, 1, scope='Conv2d_0a_1x1')
+      tower_conv1_1 = slim.conv2d(tower_conv1_0, 224, [1, 3],
+                                  scope='Conv2d_0b_1x3')
+      tower_conv1_2 = slim.conv2d(tower_conv1_1, 256, [3, 1],
+                                  scope='Conv2d_0c_3x1')
+    mixed = tf.concat(axis=3, values=[tower_conv, tower_conv1_2])
+    up = slim.conv2d(mixed, net.get_shape()[3], 1, normalizer_fn=None,
+                     activation_fn=None, scope='Conv2d_1x1')
+    net += scale * up
+    if activation_fn:
+      net = activation_fn(net)
+  return net
+
+
+def inception_resnet_v2_base(inputs,
+                             final_endpoint='Conv2d_7b_1x1',
+                             output_stride=16,
+                             align_feature_maps=False,
+                             scope=None):
+  """Inception model from  http://arxiv.org/abs/1602.07261.
+
+  Constructs an Inception Resnet v2 network from inputs to the given final
+  endpoint. This method can construct the network up to the final inception
+  block Conv2d_7b_1x1.
+
+  Args:
+    inputs: a tensor of size [batch_size, height, width, channels].
+    final_endpoint: specifies the endpoint to construct the network up to. It
+      can be one of ['Conv2d_1a_3x3', 'Conv2d_2a_3x3', 'Conv2d_2b_3x3',
+      'MaxPool_3a_3x3', 'Conv2d_3b_1x1', 'Conv2d_4a_3x3', 'MaxPool_5a_3x3',
+      'Mixed_5b', 'Mixed_6a', 'PreAuxLogits', 'Mixed_7a', 'Conv2d_7b_1x1']
+    output_stride: A scalar that specifies the requested ratio of input to
+      output spatial resolution. Only supports 8 and 16.
+    align_feature_maps: When true, changes all the VALID paddings in the network
+      to SAME padding so that the feature maps are aligned.
+    scope: Optional variable_scope.
+
+  Returns:
+    tensor_out: output tensor corresponding to the final_endpoint.
+    end_points: a set of activations for external use, for example summaries or
+                losses.
+
+  Raises:
+    ValueError: if final_endpoint is not set to one of the predefined values,
+      or if the output_stride is not 8 or 16, or if the output_stride is 8 and
+      we request an end point after 'PreAuxLogits'.
+  """
+  if output_stride != 8 and output_stride != 16:
+    raise ValueError('output_stride must be 8 or 16.')
+
+  padding = 'SAME' if align_feature_maps else 'VALID'
+
+  end_points = {}
+
+  def add_and_check_final(name, net):
+    end_points[name] = net
+    return name == final_endpoint
+
+  with tf.variable_scope(scope, 'InceptionResnetV2', [inputs]):
+    with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d],
+                        stride=1, padding='SAME'):
+      # 149 x 149 x 32
+      net = slim.conv2d(inputs, 32, 3, stride=2, padding=padding,
+                        scope='Conv2d_1a_3x3')
+      if add_and_check_final('Conv2d_1a_3x3', net): return net, end_points
+
+      # 147 x 147 x 32
+      net = slim.conv2d(net, 32, 3, padding=padding,
+                        scope='Conv2d_2a_3x3')
+      if add_and_check_final('Conv2d_2a_3x3', net): return net, end_points
+      # 147 x 147 x 64
+      net = slim.conv2d(net, 64, 3, scope='Conv2d_2b_3x3')
+      if add_and_check_final('Conv2d_2b_3x3', net): return net, end_points
+      # 73 x 73 x 64
+      net = slim.max_pool2d(net, 3, stride=2, padding=padding,
+                            scope='MaxPool_3a_3x3')
+      if add_and_check_final('MaxPool_3a_3x3', net): return net, end_points
+      # 73 x 73 x 80
+      net = slim.conv2d(net, 80, 1, padding=padding,
+                        scope='Conv2d_3b_1x1')
+      if add_and_check_final('Conv2d_3b_1x1', net): return net, end_points
+      # 71 x 71 x 192
+      net = slim.conv2d(net, 192, 3, padding=padding,
+                        scope='Conv2d_4a_3x3')
+      if add_and_check_final('Conv2d_4a_3x3', net): return net, end_points
+      # 35 x 35 x 192
+      net = slim.max_pool2d(net, 3, stride=2, padding=padding,
+                            scope='MaxPool_5a_3x3')
+      if add_and_check_final('MaxPool_5a_3x3', net): return net, end_points
+
+      # 35 x 35 x 320
+      with tf.variable_scope('Mixed_5b'):
+        with tf.variable_scope('Branch_0'):
+          tower_conv = slim.conv2d(net, 96, 1, scope='Conv2d_1x1')
+        with tf.variable_scope('Branch_1'):
+          tower_conv1_0 = slim.conv2d(net, 48, 1, scope='Conv2d_0a_1x1')
+          tower_conv1_1 = slim.conv2d(tower_conv1_0, 64, 5,
+                                      scope='Conv2d_0b_5x5')
+        with tf.variable_scope('Branch_2'):
+          tower_conv2_0 = slim.conv2d(net, 64, 1, scope='Conv2d_0a_1x1')
+          tower_conv2_1 = slim.conv2d(tower_conv2_0, 96, 3,
+                                      scope='Conv2d_0b_3x3')
+          tower_conv2_2 = slim.conv2d(tower_conv2_1, 96, 3,
+                                      scope='Conv2d_0c_3x3')
+        with tf.variable_scope('Branch_3'):
+          tower_pool = slim.avg_pool2d(net, 3, stride=1, padding='SAME',
+                                       scope='AvgPool_0a_3x3')
+          tower_pool_1 = slim.conv2d(tower_pool, 64, 1,
+                                     scope='Conv2d_0b_1x1')
+        net = tf.concat(
+            [tower_conv, tower_conv1_1, tower_conv2_2, tower_pool_1], 3)
+
+      if add_and_check_final('Mixed_5b', net): return net, end_points
+      # TODO(alemi): Register intermediate endpoints
+      net = slim.repeat(net, 10, block35, scale=0.17)
+
+      # 17 x 17 x 1088 if output_stride == 8,
+      # 33 x 33 x 1088 if output_stride == 16
+      use_atrous = output_stride == 8
+
+      with tf.variable_scope('Mixed_6a'):
+        with tf.variable_scope('Branch_0'):
+          tower_conv = slim.conv2d(net, 384, 3, stride=1 if use_atrous else 2,
+                                   padding=padding,
+                                   scope='Conv2d_1a_3x3')
+        with tf.variable_scope('Branch_1'):
+          tower_conv1_0 = slim.conv2d(net, 256, 1, scope='Conv2d_0a_1x1')
+          tower_conv1_1 = slim.conv2d(tower_conv1_0, 256, 3,
+                                      scope='Conv2d_0b_3x3')
+          tower_conv1_2 = slim.conv2d(tower_conv1_1, 384, 3,
+                                      stride=1 if use_atrous else 2,
+                                      padding=padding,
+                                      scope='Conv2d_1a_3x3')
+        with tf.variable_scope('Branch_2'):
+          tower_pool = slim.max_pool2d(net, 3, stride=1 if use_atrous else 2,
+                                       padding=padding,
+                                       scope='MaxPool_1a_3x3')
+        net = tf.concat([tower_conv, tower_conv1_2, tower_pool], 3)
+
+      if add_and_check_final('Mixed_6a', net): return net, end_points
+
+      # TODO(alemi): register intermediate endpoints
+      with slim.arg_scope([slim.conv2d], rate=2 if use_atrous else 1):
+        net = slim.repeat(net, 20, block17, scale=0.10)
+      if add_and_check_final('PreAuxLogits', net): return net, end_points
+
+      if output_stride == 8:
+        # TODO(gpapan): Properly support output_stride for the rest of the net.
+        raise ValueError('output_stride==8 is only supported up to the '
+                         'PreAuxlogits end_point for now.')
+
+      # 8 x 8 x 2080
+      with tf.variable_scope('Mixed_7a'):
+        with tf.variable_scope('Branch_0'):
+          tower_conv = slim.conv2d(net, 256, 1, scope='Conv2d_0a_1x1')
+          tower_conv_1 = slim.conv2d(tower_conv, 384, 3, stride=2,
+                                     padding=padding,
+                                     scope='Conv2d_1a_3x3')
+        with tf.variable_scope('Branch_1'):
+          tower_conv1 = slim.conv2d(net, 256, 1, scope='Conv2d_0a_1x1')
+          tower_conv1_1 = slim.conv2d(tower_conv1, 288, 3, stride=2,
+                                      padding=padding,
+                                      scope='Conv2d_1a_3x3')
+        with tf.variable_scope('Branch_2'):
+          tower_conv2 = slim.conv2d(net, 256, 1, scope='Conv2d_0a_1x1')
+          tower_conv2_1 = slim.conv2d(tower_conv2, 288, 3,
+                                      scope='Conv2d_0b_3x3')
+          tower_conv2_2 = slim.conv2d(tower_conv2_1, 320, 3, stride=2,
+                                      padding=padding,
+                                      scope='Conv2d_1a_3x3')
+        with tf.variable_scope('Branch_3'):
+          tower_pool = slim.max_pool2d(net, 3, stride=2,
+                                       padding=padding,
+                                       scope='MaxPool_1a_3x3')
+        net = tf.concat(
+            [tower_conv_1, tower_conv1_1, tower_conv2_2, tower_pool], 3)
+
+      if add_and_check_final('Mixed_7a', net): return net, end_points
+
+      # TODO(alemi): register intermediate endpoints
+      net = slim.repeat(net, 9, block8, scale=0.20)
+      net = block8(net, activation_fn=None)
+
+      # 8 x 8 x 1536
+      net = slim.conv2d(net, 1536, 1, scope='Conv2d_7b_1x1')
+      if add_and_check_final('Conv2d_7b_1x1', net): return net, end_points
+
+    raise ValueError('final_endpoint (%s) not recognized', final_endpoint)
+
+
+def inception_resnet_v2(inputs, num_classes=1001, is_training=True,
+                        dropout_keep_prob=0.8,#0.8
+                        reuse=None,
+                        scope='InceptionResnetV2',
+                        create_aux_logits=True):
+  """Creates the Inception Resnet V2 model.
+
+  Args:
+    inputs: a 4-D tensor of size [batch_size, height, width, 3].
+    num_classes: number of predicted classes.
+    is_training: whether is training or not.
+    dropout_keep_prob: float, the fraction to keep before final layer.
+    reuse: whether or not the network and its variables should be reused. To be
+      able to reuse 'scope' must be given.
+    scope: Optional variable_scope.
+    create_aux_logits: Whether to include the auxilliary logits.
+
+  Returns:
+    logits: the logits outputs of the model.
+    end_points: the set of end_points from the inception model.
+  """
+  end_points = {}
+
+  with tf.variable_scope(scope, 'InceptionResnetV2', [inputs, num_classes],
+                         reuse=reuse) as scope:
+    with slim.arg_scope([slim.batch_norm, slim.dropout],
+                        is_training=is_training):
+
+      net, end_points = inception_resnet_v2_base(inputs, scope=scope)
+
+      if create_aux_logits:
+        with tf.variable_scope('AuxLogits'):
+          aux = end_points['PreAuxLogits']
+          aux = slim.avg_pool2d(aux, 5, stride=3, padding='VALID',
+                                scope='Conv2d_1a_3x3')
+          aux = slim.conv2d(aux, 128, 1, scope='Conv2d_1b_1x1')
+          aux = slim.conv2d(aux, 768, aux.get_shape()[1:3],
+                            padding='VALID', scope='Conv2d_2a_5x5')
+          aux = slim.flatten(aux)
+          aux = slim.fully_connected(aux, num_classes, activation_fn=None,
+                                     scope='Logits')
+          end_points['AuxLogits'] = aux
+
+      with tf.variable_scope('Logits'):
+        net = slim.avg_pool2d(net, net.get_shape()[1:3], padding='VALID',
+                              scope='AvgPool_1a_8x8')
+        net = slim.flatten(net)
+
+        net = slim.dropout(net, dropout_keep_prob, is_training=is_training,
+                           scope='Dropout')
+
+        end_points['PreLogitsFlatten'] = net
+        # end_points['yjr_feature'] = tf.squeeze(net, axis=0)
+
+        logits = slim.fully_connected(net, num_classes, activation_fn=None,
+                                      scope='Logits')
+        end_points['Logits'] = logits
+        end_points['Predictions'] = tf.nn.softmax(logits, name='Predictions')
+
+    return logits, end_points
+inception_resnet_v2.default_image_size = 299
+
+
+def inception_resnet_v2_arg_scope(weight_decay=0.00004,
+                                  batch_norm_decay=0.9997,
+                                  batch_norm_epsilon=0.001):
+  """Yields the scope with the default parameters for inception_resnet_v2.
+
+  Args:
+    weight_decay: the weight decay for weights variables.
+    batch_norm_decay: decay for the moving average of batch_norm momentums.
+    batch_norm_epsilon: small float added to variance to avoid dividing by zero.
+
+  Returns:
+    a arg_scope with the parameters needed for inception_resnet_v2.
+  """
+  # Set weight_decay for weights in conv2d and fully_connected layers.
+  with slim.arg_scope([slim.conv2d, slim.fully_connected],
+                      weights_regularizer=slim.l2_regularizer(weight_decay),
+                      biases_regularizer=slim.l2_regularizer(weight_decay)):
+
+    batch_norm_params = {
+        'decay': batch_norm_decay,
+        'epsilon': batch_norm_epsilon,
+    }
+    # Set activation_fn and parameters for batch_norm.
+    with slim.arg_scope([slim.conv2d], activation_fn=tf.nn.relu,
+                        normalizer_fn=slim.batch_norm,
+                        normalizer_params=batch_norm_params) as scope:
+      return scope
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_resnet_v2_test.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_resnet_v2_test.py
new file mode 100755
index 0000000..c369ed9
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_resnet_v2_test.py
@@ -0,0 +1,265 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for slim.inception_resnet_v2."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf
+
+from nets import inception
+
+
+class InceptionTest(tf.test.TestCase):
+
+  def testBuildLogits(self):
+    batch_size = 5
+    height, width = 299, 299
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, endpoints = inception.inception_resnet_v2(inputs, num_classes)
+      self.assertTrue('AuxLogits' in endpoints)
+      auxlogits = endpoints['AuxLogits']
+      self.assertTrue(
+          auxlogits.op.name.startswith('InceptionResnetV2/AuxLogits'))
+      self.assertListEqual(auxlogits.get_shape().as_list(),
+                           [batch_size, num_classes])
+      self.assertTrue(logits.op.name.startswith('InceptionResnetV2/Logits'))
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [batch_size, num_classes])
+
+  def testBuildWithoutAuxLogits(self):
+    batch_size = 5
+    height, width = 299, 299
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, endpoints = inception.inception_resnet_v2(inputs, num_classes,
+                                                        create_aux_logits=False)
+      self.assertTrue('AuxLogits' not in endpoints)
+      self.assertTrue(logits.op.name.startswith('InceptionResnetV2/Logits'))
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [batch_size, num_classes])
+
+  def testBuildEndPoints(self):
+    batch_size = 5
+    height, width = 299, 299
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      _, end_points = inception.inception_resnet_v2(inputs, num_classes)
+      self.assertTrue('Logits' in end_points)
+      logits = end_points['Logits']
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [batch_size, num_classes])
+      self.assertTrue('AuxLogits' in end_points)
+      aux_logits = end_points['AuxLogits']
+      self.assertListEqual(aux_logits.get_shape().as_list(),
+                           [batch_size, num_classes])
+      pre_pool = end_points['Conv2d_7b_1x1']
+      self.assertListEqual(pre_pool.get_shape().as_list(),
+                           [batch_size, 8, 8, 1536])
+
+  def testBuildBaseNetwork(self):
+    batch_size = 5
+    height, width = 299, 299
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    net, end_points = inception.inception_resnet_v2_base(inputs)
+    self.assertTrue(net.op.name.startswith('InceptionResnetV2/Conv2d_7b_1x1'))
+    self.assertListEqual(net.get_shape().as_list(),
+                         [batch_size, 8, 8, 1536])
+    expected_endpoints = ['Conv2d_1a_3x3', 'Conv2d_2a_3x3', 'Conv2d_2b_3x3',
+                          'MaxPool_3a_3x3', 'Conv2d_3b_1x1', 'Conv2d_4a_3x3',
+                          'MaxPool_5a_3x3', 'Mixed_5b', 'Mixed_6a',
+                          'PreAuxLogits', 'Mixed_7a', 'Conv2d_7b_1x1']
+    self.assertItemsEqual(end_points.keys(), expected_endpoints)
+
+  def testBuildOnlyUptoFinalEndpoint(self):
+    batch_size = 5
+    height, width = 299, 299
+    endpoints = ['Conv2d_1a_3x3', 'Conv2d_2a_3x3', 'Conv2d_2b_3x3',
+                 'MaxPool_3a_3x3', 'Conv2d_3b_1x1', 'Conv2d_4a_3x3',
+                 'MaxPool_5a_3x3', 'Mixed_5b', 'Mixed_6a',
+                 'PreAuxLogits', 'Mixed_7a', 'Conv2d_7b_1x1']
+    for index, endpoint in enumerate(endpoints):
+      with tf.Graph().as_default():
+        inputs = tf.random_uniform((batch_size, height, width, 3))
+        out_tensor, end_points = inception.inception_resnet_v2_base(
+            inputs, final_endpoint=endpoint)
+        if endpoint != 'PreAuxLogits':
+          self.assertTrue(out_tensor.op.name.startswith(
+              'InceptionResnetV2/' + endpoint))
+        self.assertItemsEqual(endpoints[:index+1], end_points)
+
+  def testBuildAndCheckAllEndPointsUptoPreAuxLogits(self):
+    batch_size = 5
+    height, width = 299, 299
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    _, end_points = inception.inception_resnet_v2_base(
+        inputs, final_endpoint='PreAuxLogits')
+    endpoints_shapes = {'Conv2d_1a_3x3': [5, 149, 149, 32],
+                        'Conv2d_2a_3x3': [5, 147, 147, 32],
+                        'Conv2d_2b_3x3': [5, 147, 147, 64],
+                        'MaxPool_3a_3x3': [5, 73, 73, 64],
+                        'Conv2d_3b_1x1': [5, 73, 73, 80],
+                        'Conv2d_4a_3x3': [5, 71, 71, 192],
+                        'MaxPool_5a_3x3': [5, 35, 35, 192],
+                        'Mixed_5b': [5, 35, 35, 320],
+                        'Mixed_6a': [5, 17, 17, 1088],
+                        'PreAuxLogits': [5, 17, 17, 1088]
+                       }
+
+    self.assertItemsEqual(endpoints_shapes.keys(), end_points.keys())
+    for endpoint_name in endpoints_shapes:
+      expected_shape = endpoints_shapes[endpoint_name]
+      self.assertTrue(endpoint_name in end_points)
+      self.assertListEqual(end_points[endpoint_name].get_shape().as_list(),
+                           expected_shape)
+
+  def testBuildAndCheckAllEndPointsUptoPreAuxLogitsWithAlignedFeatureMaps(self):
+    batch_size = 5
+    height, width = 299, 299
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    _, end_points = inception.inception_resnet_v2_base(
+        inputs, final_endpoint='PreAuxLogits', align_feature_maps=True)
+    endpoints_shapes = {'Conv2d_1a_3x3': [5, 150, 150, 32],
+                        'Conv2d_2a_3x3': [5, 150, 150, 32],
+                        'Conv2d_2b_3x3': [5, 150, 150, 64],
+                        'MaxPool_3a_3x3': [5, 75, 75, 64],
+                        'Conv2d_3b_1x1': [5, 75, 75, 80],
+                        'Conv2d_4a_3x3': [5, 75, 75, 192],
+                        'MaxPool_5a_3x3': [5, 38, 38, 192],
+                        'Mixed_5b': [5, 38, 38, 320],
+                        'Mixed_6a': [5, 19, 19, 1088],
+                        'PreAuxLogits': [5, 19, 19, 1088]
+                       }
+
+    self.assertItemsEqual(endpoints_shapes.keys(), end_points.keys())
+    for endpoint_name in endpoints_shapes:
+      expected_shape = endpoints_shapes[endpoint_name]
+      self.assertTrue(endpoint_name in end_points)
+      self.assertListEqual(end_points[endpoint_name].get_shape().as_list(),
+                           expected_shape)
+
+  def testBuildAndCheckAllEndPointsUptoPreAuxLogitsWithOutputStrideEight(self):
+    batch_size = 5
+    height, width = 299, 299
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    _, end_points = inception.inception_resnet_v2_base(
+        inputs, final_endpoint='PreAuxLogits', output_stride=8)
+    endpoints_shapes = {'Conv2d_1a_3x3': [5, 149, 149, 32],
+                        'Conv2d_2a_3x3': [5, 147, 147, 32],
+                        'Conv2d_2b_3x3': [5, 147, 147, 64],
+                        'MaxPool_3a_3x3': [5, 73, 73, 64],
+                        'Conv2d_3b_1x1': [5, 73, 73, 80],
+                        'Conv2d_4a_3x3': [5, 71, 71, 192],
+                        'MaxPool_5a_3x3': [5, 35, 35, 192],
+                        'Mixed_5b': [5, 35, 35, 320],
+                        'Mixed_6a': [5, 33, 33, 1088],
+                        'PreAuxLogits': [5, 33, 33, 1088]
+                       }
+
+    self.assertItemsEqual(endpoints_shapes.keys(), end_points.keys())
+    for endpoint_name in endpoints_shapes:
+      expected_shape = endpoints_shapes[endpoint_name]
+      self.assertTrue(endpoint_name in end_points)
+      self.assertListEqual(end_points[endpoint_name].get_shape().as_list(),
+                           expected_shape)
+
+  def testVariablesSetDevice(self):
+    batch_size = 5
+    height, width = 299, 299
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      # Force all Variables to reside on the device.
+      with tf.variable_scope('on_cpu'), tf.device('/cpu:0'):
+        inception.inception_resnet_v2(inputs, num_classes)
+      with tf.variable_scope('on_gpu'), tf.device('/gpu:0'):
+        inception.inception_resnet_v2(inputs, num_classes)
+      for v in tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='on_cpu'):
+        self.assertDeviceEqual(v.device, '/cpu:0')
+      for v in tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='on_gpu'):
+        self.assertDeviceEqual(v.device, '/gpu:0')
+
+  def testHalfSizeImages(self):
+    batch_size = 5
+    height, width = 150, 150
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, end_points = inception.inception_resnet_v2(inputs, num_classes)
+      self.assertTrue(logits.op.name.startswith('InceptionResnetV2/Logits'))
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [batch_size, num_classes])
+      pre_pool = end_points['Conv2d_7b_1x1']
+      self.assertListEqual(pre_pool.get_shape().as_list(),
+                           [batch_size, 3, 3, 1536])
+
+  def testUnknownBatchSize(self):
+    batch_size = 1
+    height, width = 299, 299
+    num_classes = 1000
+    with self.test_session() as sess:
+      inputs = tf.placeholder(tf.float32, (None, height, width, 3))
+      logits, _ = inception.inception_resnet_v2(inputs, num_classes)
+      self.assertTrue(logits.op.name.startswith('InceptionResnetV2/Logits'))
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [None, num_classes])
+      images = tf.random_uniform((batch_size, height, width, 3))
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(logits, {inputs: images.eval()})
+      self.assertEquals(output.shape, (batch_size, num_classes))
+
+  def testEvaluation(self):
+    batch_size = 2
+    height, width = 299, 299
+    num_classes = 1000
+    with self.test_session() as sess:
+      eval_inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, _ = inception.inception_resnet_v2(eval_inputs,
+                                                num_classes,
+                                                is_training=False)
+      predictions = tf.argmax(logits, 1)
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(predictions)
+      self.assertEquals(output.shape, (batch_size,))
+
+  def testTrainEvalWithReuse(self):
+    train_batch_size = 5
+    eval_batch_size = 2
+    height, width = 150, 150
+    num_classes = 1000
+    with self.test_session() as sess:
+      train_inputs = tf.random_uniform((train_batch_size, height, width, 3))
+      inception.inception_resnet_v2(train_inputs, num_classes)
+      eval_inputs = tf.random_uniform((eval_batch_size, height, width, 3))
+      logits, _ = inception.inception_resnet_v2(eval_inputs,
+                                                num_classes,
+                                                is_training=False,
+                                                reuse=True)
+      predictions = tf.argmax(logits, 1)
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(predictions)
+      self.assertEquals(output.shape, (eval_batch_size,))
+
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_utils.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_utils.py
new file mode 100755
index 0000000..66ee41f
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_utils.py
@@ -0,0 +1,71 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Contains common code shared by all inception models.
+
+Usage of arg scope:
+  with slim.arg_scope(inception_arg_scope()):
+    logits, end_points = inception.inception_v3(images, num_classes,
+                                                is_training=is_training)
+
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf
+
+slim = tf.contrib.slim
+
+
+def inception_arg_scope(weight_decay=0.00004,
+                        use_batch_norm=True,
+                        batch_norm_decay=0.9997,
+                        batch_norm_epsilon=0.001):
+  """Defines the default arg scope for inception models.
+
+  Args:
+    weight_decay: The weight decay to use for regularizing the model.
+    use_batch_norm: "If `True`, batch_norm is applied after each convolution.
+    batch_norm_decay: Decay for batch norm moving average.
+    batch_norm_epsilon: Small float added to variance to avoid dividing by zero
+      in batch norm.
+
+  Returns:
+    An `arg_scope` to use for the inception models.
+  """
+  batch_norm_params = {
+      # Decay for the moving averages.
+      'decay': batch_norm_decay,
+      # epsilon to prevent 0s in variance.
+      'epsilon': batch_norm_epsilon,
+      # collection containing update_ops.
+      'updates_collections': tf.GraphKeys.UPDATE_OPS,
+  }
+  if use_batch_norm:
+    normalizer_fn = slim.batch_norm
+    normalizer_params = batch_norm_params
+  else:
+    normalizer_fn = None
+    normalizer_params = {}
+  # Set weight_decay for weights in Conv and FC layers.
+  with slim.arg_scope([slim.conv2d, slim.fully_connected],
+                      weights_regularizer=slim.l2_regularizer(weight_decay)):
+    with slim.arg_scope(
+        [slim.conv2d],
+        weights_initializer=slim.variance_scaling_initializer(),
+        activation_fn=tf.nn.relu,
+        normalizer_fn=normalizer_fn,
+        normalizer_params=normalizer_params) as sc:
+      return sc
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_v1.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_v1.py
new file mode 100755
index 0000000..4207c2a
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_v1.py
@@ -0,0 +1,305 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Contains the definition for inception v1 classification network."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf
+
+from nets import inception_utils
+
+slim = tf.contrib.slim
+trunc_normal = lambda stddev: tf.truncated_normal_initializer(0.0, stddev)
+
+
+def inception_v1_base(inputs,
+                      final_endpoint='Mixed_5c',
+                      scope='InceptionV1'):
+  """Defines the Inception V1 base architecture.
+
+  This architecture is defined in:
+    Going deeper with convolutions
+    Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed,
+    Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, Andrew Rabinovich.
+    http://arxiv.org/pdf/1409.4842v1.pdf.
+
+  Args:
+    inputs: a tensor of size [batch_size, height, width, channels].
+    final_endpoint: specifies the endpoint to construct the network up to. It
+      can be one of ['Conv2d_1a_7x7', 'MaxPool_2a_3x3', 'Conv2d_2b_1x1',
+      'Conv2d_2c_3x3', 'MaxPool_3a_3x3', 'Mixed_3b', 'Mixed_3c',
+      'MaxPool_4a_3x3', 'Mixed_4b', 'Mixed_4c', 'Mixed_4d', 'Mixed_4e',
+      'Mixed_4f', 'MaxPool_5a_2x2', 'Mixed_5b', 'Mixed_5c']
+    scope: Optional variable_scope.
+
+  Returns:
+    A dictionary from components of the network to the corresponding activation.
+
+  Raises:
+    ValueError: if final_endpoint is not set to one of the predefined values.
+  """
+  end_points = {}
+  with tf.variable_scope(scope, 'InceptionV1', [inputs]):
+    with slim.arg_scope(
+        [slim.conv2d, slim.fully_connected],
+        weights_initializer=trunc_normal(0.01)):
+      with slim.arg_scope([slim.conv2d, slim.max_pool2d],
+                          stride=1, padding='SAME'):
+        end_point = 'Conv2d_1a_7x7'
+        net = slim.conv2d(inputs, 64, [7, 7], stride=2, scope=end_point)
+        end_points[end_point] = net
+        if final_endpoint == end_point: return net, end_points
+        end_point = 'MaxPool_2a_3x3'
+        net = slim.max_pool2d(net, [3, 3], stride=2, scope=end_point)
+        end_points[end_point] = net
+        if final_endpoint == end_point: return net, end_points
+        end_point = 'Conv2d_2b_1x1'
+        net = slim.conv2d(net, 64, [1, 1], scope=end_point)
+        end_points[end_point] = net
+        if final_endpoint == end_point: return net, end_points
+        end_point = 'Conv2d_2c_3x3'
+        net = slim.conv2d(net, 192, [3, 3], scope=end_point)
+        end_points[end_point] = net
+        if final_endpoint == end_point: return net, end_points
+        end_point = 'MaxPool_3a_3x3'
+        net = slim.max_pool2d(net, [3, 3], stride=2, scope=end_point)
+        end_points[end_point] = net
+        if final_endpoint == end_point: return net, end_points
+
+        end_point = 'Mixed_3b'
+        with tf.variable_scope(end_point):
+          with tf.variable_scope('Branch_0'):
+            branch_0 = slim.conv2d(net, 64, [1, 1], scope='Conv2d_0a_1x1')
+          with tf.variable_scope('Branch_1'):
+            branch_1 = slim.conv2d(net, 96, [1, 1], scope='Conv2d_0a_1x1')
+            branch_1 = slim.conv2d(branch_1, 128, [3, 3], scope='Conv2d_0b_3x3')
+          with tf.variable_scope('Branch_2'):
+            branch_2 = slim.conv2d(net, 16, [1, 1], scope='Conv2d_0a_1x1')
+            branch_2 = slim.conv2d(branch_2, 32, [3, 3], scope='Conv2d_0b_3x3')
+          with tf.variable_scope('Branch_3'):
+            branch_3 = slim.max_pool2d(net, [3, 3], scope='MaxPool_0a_3x3')
+            branch_3 = slim.conv2d(branch_3, 32, [1, 1], scope='Conv2d_0b_1x1')
+          net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+        end_points[end_point] = net
+        if final_endpoint == end_point: return net, end_points
+
+        end_point = 'Mixed_3c'
+        with tf.variable_scope(end_point):
+          with tf.variable_scope('Branch_0'):
+            branch_0 = slim.conv2d(net, 128, [1, 1], scope='Conv2d_0a_1x1')
+          with tf.variable_scope('Branch_1'):
+            branch_1 = slim.conv2d(net, 128, [1, 1], scope='Conv2d_0a_1x1')
+            branch_1 = slim.conv2d(branch_1, 192, [3, 3], scope='Conv2d_0b_3x3')
+          with tf.variable_scope('Branch_2'):
+            branch_2 = slim.conv2d(net, 32, [1, 1], scope='Conv2d_0a_1x1')
+            branch_2 = slim.conv2d(branch_2, 96, [3, 3], scope='Conv2d_0b_3x3')
+          with tf.variable_scope('Branch_3'):
+            branch_3 = slim.max_pool2d(net, [3, 3], scope='MaxPool_0a_3x3')
+            branch_3 = slim.conv2d(branch_3, 64, [1, 1], scope='Conv2d_0b_1x1')
+          net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+        end_points[end_point] = net
+        if final_endpoint == end_point: return net, end_points
+
+        end_point = 'MaxPool_4a_3x3'
+        net = slim.max_pool2d(net, [3, 3], stride=2, scope=end_point)
+        end_points[end_point] = net
+        if final_endpoint == end_point: return net, end_points
+
+        end_point = 'Mixed_4b'
+        with tf.variable_scope(end_point):
+          with tf.variable_scope('Branch_0'):
+            branch_0 = slim.conv2d(net, 192, [1, 1], scope='Conv2d_0a_1x1')
+          with tf.variable_scope('Branch_1'):
+            branch_1 = slim.conv2d(net, 96, [1, 1], scope='Conv2d_0a_1x1')
+            branch_1 = slim.conv2d(branch_1, 208, [3, 3], scope='Conv2d_0b_3x3')
+          with tf.variable_scope('Branch_2'):
+            branch_2 = slim.conv2d(net, 16, [1, 1], scope='Conv2d_0a_1x1')
+            branch_2 = slim.conv2d(branch_2, 48, [3, 3], scope='Conv2d_0b_3x3')
+          with tf.variable_scope('Branch_3'):
+            branch_3 = slim.max_pool2d(net, [3, 3], scope='MaxPool_0a_3x3')
+            branch_3 = slim.conv2d(branch_3, 64, [1, 1], scope='Conv2d_0b_1x1')
+          net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+        end_points[end_point] = net
+        if final_endpoint == end_point: return net, end_points
+
+        end_point = 'Mixed_4c'
+        with tf.variable_scope(end_point):
+          with tf.variable_scope('Branch_0'):
+            branch_0 = slim.conv2d(net, 160, [1, 1], scope='Conv2d_0a_1x1')
+          with tf.variable_scope('Branch_1'):
+            branch_1 = slim.conv2d(net, 112, [1, 1], scope='Conv2d_0a_1x1')
+            branch_1 = slim.conv2d(branch_1, 224, [3, 3], scope='Conv2d_0b_3x3')
+          with tf.variable_scope('Branch_2'):
+            branch_2 = slim.conv2d(net, 24, [1, 1], scope='Conv2d_0a_1x1')
+            branch_2 = slim.conv2d(branch_2, 64, [3, 3], scope='Conv2d_0b_3x3')
+          with tf.variable_scope('Branch_3'):
+            branch_3 = slim.max_pool2d(net, [3, 3], scope='MaxPool_0a_3x3')
+            branch_3 = slim.conv2d(branch_3, 64, [1, 1], scope='Conv2d_0b_1x1')
+          net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+        end_points[end_point] = net
+        if final_endpoint == end_point: return net, end_points
+
+        end_point = 'Mixed_4d'
+        with tf.variable_scope(end_point):
+          with tf.variable_scope('Branch_0'):
+            branch_0 = slim.conv2d(net, 128, [1, 1], scope='Conv2d_0a_1x1')
+          with tf.variable_scope('Branch_1'):
+            branch_1 = slim.conv2d(net, 128, [1, 1], scope='Conv2d_0a_1x1')
+            branch_1 = slim.conv2d(branch_1, 256, [3, 3], scope='Conv2d_0b_3x3')
+          with tf.variable_scope('Branch_2'):
+            branch_2 = slim.conv2d(net, 24, [1, 1], scope='Conv2d_0a_1x1')
+            branch_2 = slim.conv2d(branch_2, 64, [3, 3], scope='Conv2d_0b_3x3')
+          with tf.variable_scope('Branch_3'):
+            branch_3 = slim.max_pool2d(net, [3, 3], scope='MaxPool_0a_3x3')
+            branch_3 = slim.conv2d(branch_3, 64, [1, 1], scope='Conv2d_0b_1x1')
+          net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+        end_points[end_point] = net
+        if final_endpoint == end_point: return net, end_points
+
+        end_point = 'Mixed_4e'
+        with tf.variable_scope(end_point):
+          with tf.variable_scope('Branch_0'):
+            branch_0 = slim.conv2d(net, 112, [1, 1], scope='Conv2d_0a_1x1')
+          with tf.variable_scope('Branch_1'):
+            branch_1 = slim.conv2d(net, 144, [1, 1], scope='Conv2d_0a_1x1')
+            branch_1 = slim.conv2d(branch_1, 288, [3, 3], scope='Conv2d_0b_3x3')
+          with tf.variable_scope('Branch_2'):
+            branch_2 = slim.conv2d(net, 32, [1, 1], scope='Conv2d_0a_1x1')
+            branch_2 = slim.conv2d(branch_2, 64, [3, 3], scope='Conv2d_0b_3x3')
+          with tf.variable_scope('Branch_3'):
+            branch_3 = slim.max_pool2d(net, [3, 3], scope='MaxPool_0a_3x3')
+            branch_3 = slim.conv2d(branch_3, 64, [1, 1], scope='Conv2d_0b_1x1')
+          net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+        end_points[end_point] = net
+        if final_endpoint == end_point: return net, end_points
+
+        end_point = 'Mixed_4f'
+        with tf.variable_scope(end_point):
+          with tf.variable_scope('Branch_0'):
+            branch_0 = slim.conv2d(net, 256, [1, 1], scope='Conv2d_0a_1x1')
+          with tf.variable_scope('Branch_1'):
+            branch_1 = slim.conv2d(net, 160, [1, 1], scope='Conv2d_0a_1x1')
+            branch_1 = slim.conv2d(branch_1, 320, [3, 3], scope='Conv2d_0b_3x3')
+          with tf.variable_scope('Branch_2'):
+            branch_2 = slim.conv2d(net, 32, [1, 1], scope='Conv2d_0a_1x1')
+            branch_2 = slim.conv2d(branch_2, 128, [3, 3], scope='Conv2d_0b_3x3')
+          with tf.variable_scope('Branch_3'):
+            branch_3 = slim.max_pool2d(net, [3, 3], scope='MaxPool_0a_3x3')
+            branch_3 = slim.conv2d(branch_3, 128, [1, 1], scope='Conv2d_0b_1x1')
+          net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+        end_points[end_point] = net
+        if final_endpoint == end_point: return net, end_points
+
+        end_point = 'MaxPool_5a_2x2'
+        net = slim.max_pool2d(net, [2, 2], stride=2, scope=end_point)
+        end_points[end_point] = net
+        if final_endpoint == end_point: return net, end_points
+
+        end_point = 'Mixed_5b'
+        with tf.variable_scope(end_point):
+          with tf.variable_scope('Branch_0'):
+            branch_0 = slim.conv2d(net, 256, [1, 1], scope='Conv2d_0a_1x1')
+          with tf.variable_scope('Branch_1'):
+            branch_1 = slim.conv2d(net, 160, [1, 1], scope='Conv2d_0a_1x1')
+            branch_1 = slim.conv2d(branch_1, 320, [3, 3], scope='Conv2d_0b_3x3')
+          with tf.variable_scope('Branch_2'):
+            branch_2 = slim.conv2d(net, 32, [1, 1], scope='Conv2d_0a_1x1')
+            branch_2 = slim.conv2d(branch_2, 128, [3, 3], scope='Conv2d_0a_3x3')
+          with tf.variable_scope('Branch_3'):
+            branch_3 = slim.max_pool2d(net, [3, 3], scope='MaxPool_0a_3x3')
+            branch_3 = slim.conv2d(branch_3, 128, [1, 1], scope='Conv2d_0b_1x1')
+          net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+        end_points[end_point] = net
+        if final_endpoint == end_point: return net, end_points
+
+        end_point = 'Mixed_5c'
+        with tf.variable_scope(end_point):
+          with tf.variable_scope('Branch_0'):
+            branch_0 = slim.conv2d(net, 384, [1, 1], scope='Conv2d_0a_1x1')
+          with tf.variable_scope('Branch_1'):
+            branch_1 = slim.conv2d(net, 192, [1, 1], scope='Conv2d_0a_1x1')
+            branch_1 = slim.conv2d(branch_1, 384, [3, 3], scope='Conv2d_0b_3x3')
+          with tf.variable_scope('Branch_2'):
+            branch_2 = slim.conv2d(net, 48, [1, 1], scope='Conv2d_0a_1x1')
+            branch_2 = slim.conv2d(branch_2, 128, [3, 3], scope='Conv2d_0b_3x3')
+          with tf.variable_scope('Branch_3'):
+            branch_3 = slim.max_pool2d(net, [3, 3], scope='MaxPool_0a_3x3')
+            branch_3 = slim.conv2d(branch_3, 128, [1, 1], scope='Conv2d_0b_1x1')
+          net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+        end_points[end_point] = net
+        if final_endpoint == end_point: return net, end_points
+    raise ValueError('Unknown final endpoint %s' % final_endpoint)
+
+
+def inception_v1(inputs,
+                 num_classes=1000,
+                 is_training=True,
+                 dropout_keep_prob=0.8,
+                 prediction_fn=slim.softmax,
+                 spatial_squeeze=True,
+                 reuse=None,
+                 scope='InceptionV1'):
+  """Defines the Inception V1 architecture.
+
+  This architecture is defined in:
+
+    Going deeper with convolutions
+    Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed,
+    Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, Andrew Rabinovich.
+    http://arxiv.org/pdf/1409.4842v1.pdf.
+
+  The default image size used to train this network is 224x224.
+
+  Args:
+    inputs: a tensor of size [batch_size, height, width, channels].
+    num_classes: number of predicted classes.
+    is_training: whether is training or not.
+    dropout_keep_prob: the percentage of activation values that are retained.
+    prediction_fn: a function to get predictions out of logits.
+    spatial_squeeze: if True, logits is of shape [B, C], if false logits is
+        of shape [B, 1, 1, C], where B is batch_size and C is number of classes.
+    reuse: whether or not the network and its variables should be reused. To be
+      able to reuse 'scope' must be given.
+    scope: Optional variable_scope.
+
+  Returns:
+    logits: the pre-softmax activations, a tensor of size
+      [batch_size, num_classes]
+    end_points: a dictionary from components of the network to the corresponding
+      activation.
+  """
+  # Final pooling and prediction
+  with tf.variable_scope(scope, 'InceptionV1', [inputs, num_classes],
+                         reuse=reuse) as scope:
+    with slim.arg_scope([slim.batch_norm, slim.dropout],
+                        is_training=is_training):
+      net, end_points = inception_v1_base(inputs, scope=scope)
+      with tf.variable_scope('Logits'):
+        net = slim.avg_pool2d(net, [7, 7], stride=1, scope='AvgPool_0a_7x7')
+        net = slim.dropout(net,
+                           dropout_keep_prob, scope='Dropout_0b')
+        logits = slim.conv2d(net, num_classes, [1, 1], activation_fn=None,
+                             normalizer_fn=None, scope='Conv2d_0c_1x1')
+        if spatial_squeeze:
+          logits = tf.squeeze(logits, [1, 2], name='SpatialSqueeze')
+
+        end_points['Logits'] = logits
+        end_points['Predictions'] = prediction_fn(logits, scope='Predictions')
+  return logits, end_points
+inception_v1.default_image_size = 224
+
+inception_v1_arg_scope = inception_utils.inception_arg_scope
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_v1_test.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_v1_test.py
new file mode 100755
index 0000000..11eb14e
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_v1_test.py
@@ -0,0 +1,210 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for slim_nets.inception_v1."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import numpy as np
+import tensorflow as tf
+
+from nets import inception
+
+slim = tf.contrib.slim
+
+
+class InceptionV1Test(tf.test.TestCase):
+
+  def testBuildClassificationNetwork(self):
+    batch_size = 5
+    height, width = 224, 224
+    num_classes = 1000
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    logits, end_points = inception.inception_v1(inputs, num_classes)
+    self.assertTrue(logits.op.name.startswith('InceptionV1/Logits'))
+    self.assertListEqual(logits.get_shape().as_list(),
+                         [batch_size, num_classes])
+    self.assertTrue('Predictions' in end_points)
+    self.assertListEqual(end_points['Predictions'].get_shape().as_list(),
+                         [batch_size, num_classes])
+
+  def testBuildBaseNetwork(self):
+    batch_size = 5
+    height, width = 224, 224
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    mixed_6c, end_points = inception.inception_v1_base(inputs)
+    self.assertTrue(mixed_6c.op.name.startswith('InceptionV1/Mixed_5c'))
+    self.assertListEqual(mixed_6c.get_shape().as_list(),
+                         [batch_size, 7, 7, 1024])
+    expected_endpoints = ['Conv2d_1a_7x7', 'MaxPool_2a_3x3', 'Conv2d_2b_1x1',
+                          'Conv2d_2c_3x3', 'MaxPool_3a_3x3', 'Mixed_3b',
+                          'Mixed_3c', 'MaxPool_4a_3x3', 'Mixed_4b', 'Mixed_4c',
+                          'Mixed_4d', 'Mixed_4e', 'Mixed_4f', 'MaxPool_5a_2x2',
+                          'Mixed_5b', 'Mixed_5c']
+    self.assertItemsEqual(end_points.keys(), expected_endpoints)
+
+  def testBuildOnlyUptoFinalEndpoint(self):
+    batch_size = 5
+    height, width = 224, 224
+    endpoints = ['Conv2d_1a_7x7', 'MaxPool_2a_3x3', 'Conv2d_2b_1x1',
+                 'Conv2d_2c_3x3', 'MaxPool_3a_3x3', 'Mixed_3b', 'Mixed_3c',
+                 'MaxPool_4a_3x3', 'Mixed_4b', 'Mixed_4c', 'Mixed_4d',
+                 'Mixed_4e', 'Mixed_4f', 'MaxPool_5a_2x2', 'Mixed_5b',
+                 'Mixed_5c']
+    for index, endpoint in enumerate(endpoints):
+      with tf.Graph().as_default():
+        inputs = tf.random_uniform((batch_size, height, width, 3))
+        out_tensor, end_points = inception.inception_v1_base(
+            inputs, final_endpoint=endpoint)
+        self.assertTrue(out_tensor.op.name.startswith(
+            'InceptionV1/' + endpoint))
+        self.assertItemsEqual(endpoints[:index+1], end_points)
+
+  def testBuildAndCheckAllEndPointsUptoMixed5c(self):
+    batch_size = 5
+    height, width = 224, 224
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    _, end_points = inception.inception_v1_base(inputs,
+                                                final_endpoint='Mixed_5c')
+    endpoints_shapes = {'Conv2d_1a_7x7': [5, 112, 112, 64],
+                        'MaxPool_2a_3x3': [5, 56, 56, 64],
+                        'Conv2d_2b_1x1': [5, 56, 56, 64],
+                        'Conv2d_2c_3x3': [5, 56, 56, 192],
+                        'MaxPool_3a_3x3': [5, 28, 28, 192],
+                        'Mixed_3b': [5, 28, 28, 256],
+                        'Mixed_3c': [5, 28, 28, 480],
+                        'MaxPool_4a_3x3': [5, 14, 14, 480],
+                        'Mixed_4b': [5, 14, 14, 512],
+                        'Mixed_4c': [5, 14, 14, 512],
+                        'Mixed_4d': [5, 14, 14, 512],
+                        'Mixed_4e': [5, 14, 14, 528],
+                        'Mixed_4f': [5, 14, 14, 832],
+                        'MaxPool_5a_2x2': [5, 7, 7, 832],
+                        'Mixed_5b': [5, 7, 7, 832],
+                        'Mixed_5c': [5, 7, 7, 1024]}
+
+    self.assertItemsEqual(endpoints_shapes.keys(), end_points.keys())
+    for endpoint_name in endpoints_shapes:
+      expected_shape = endpoints_shapes[endpoint_name]
+      self.assertTrue(endpoint_name in end_points)
+      self.assertListEqual(end_points[endpoint_name].get_shape().as_list(),
+                           expected_shape)
+
+  def testModelHasExpectedNumberOfParameters(self):
+    batch_size = 5
+    height, width = 224, 224
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    with slim.arg_scope(inception.inception_v1_arg_scope()):
+      inception.inception_v1_base(inputs)
+    total_params, _ = slim.model_analyzer.analyze_vars(
+        slim.get_model_variables())
+    self.assertAlmostEqual(5607184, total_params)
+
+  def testHalfSizeImages(self):
+    batch_size = 5
+    height, width = 112, 112
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    mixed_5c, _ = inception.inception_v1_base(inputs)
+    self.assertTrue(mixed_5c.op.name.startswith('InceptionV1/Mixed_5c'))
+    self.assertListEqual(mixed_5c.get_shape().as_list(),
+                         [batch_size, 4, 4, 1024])
+
+  def testUnknownImageShape(self):
+    tf.reset_default_graph()
+    batch_size = 2
+    height, width = 224, 224
+    num_classes = 1000
+    input_np = np.random.uniform(0, 1, (batch_size, height, width, 3))
+    with self.test_session() as sess:
+      inputs = tf.placeholder(tf.float32, shape=(batch_size, None, None, 3))
+      logits, end_points = inception.inception_v1(inputs, num_classes)
+      self.assertTrue(logits.op.name.startswith('InceptionV1/Logits'))
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [batch_size, num_classes])
+      pre_pool = end_points['Mixed_5c']
+      feed_dict = {inputs: input_np}
+      tf.global_variables_initializer().run()
+      pre_pool_out = sess.run(pre_pool, feed_dict=feed_dict)
+      self.assertListEqual(list(pre_pool_out.shape), [batch_size, 7, 7, 1024])
+
+  def testUnknowBatchSize(self):
+    batch_size = 1
+    height, width = 224, 224
+    num_classes = 1000
+
+    inputs = tf.placeholder(tf.float32, (None, height, width, 3))
+    logits, _ = inception.inception_v1(inputs, num_classes)
+    self.assertTrue(logits.op.name.startswith('InceptionV1/Logits'))
+    self.assertListEqual(logits.get_shape().as_list(),
+                         [None, num_classes])
+    images = tf.random_uniform((batch_size, height, width, 3))
+
+    with self.test_session() as sess:
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(logits, {inputs: images.eval()})
+      self.assertEquals(output.shape, (batch_size, num_classes))
+
+  def testEvaluation(self):
+    batch_size = 2
+    height, width = 224, 224
+    num_classes = 1000
+
+    eval_inputs = tf.random_uniform((batch_size, height, width, 3))
+    logits, _ = inception.inception_v1(eval_inputs, num_classes,
+                                       is_training=False)
+    predictions = tf.argmax(logits, 1)
+
+    with self.test_session() as sess:
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(predictions)
+      self.assertEquals(output.shape, (batch_size,))
+
+  def testTrainEvalWithReuse(self):
+    train_batch_size = 5
+    eval_batch_size = 2
+    height, width = 224, 224
+    num_classes = 1000
+
+    train_inputs = tf.random_uniform((train_batch_size, height, width, 3))
+    inception.inception_v1(train_inputs, num_classes)
+    eval_inputs = tf.random_uniform((eval_batch_size, height, width, 3))
+    logits, _ = inception.inception_v1(eval_inputs, num_classes, reuse=True)
+    predictions = tf.argmax(logits, 1)
+
+    with self.test_session() as sess:
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(predictions)
+      self.assertEquals(output.shape, (eval_batch_size,))
+
+  def testLogitsNotSqueezed(self):
+    num_classes = 25
+    images = tf.random_uniform([1, 224, 224, 3])
+    logits, _ = inception.inception_v1(images,
+                                       num_classes=num_classes,
+                                       spatial_squeeze=False)
+
+    with self.test_session() as sess:
+      tf.global_variables_initializer().run()
+      logits_out = sess.run(logits)
+      self.assertListEqual(list(logits_out.shape), [1, 1, 1, num_classes])
+
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_v2.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_v2.py
new file mode 100755
index 0000000..2651f71
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_v2.py
@@ -0,0 +1,520 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Contains the definition for inception v2 classification network."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf
+
+from nets import inception_utils
+
+slim = tf.contrib.slim
+trunc_normal = lambda stddev: tf.truncated_normal_initializer(0.0, stddev)
+
+
+def inception_v2_base(inputs,
+                      final_endpoint='Mixed_5c',
+                      min_depth=16,
+                      depth_multiplier=1.0,
+                      scope=None):
+  """Inception v2 (6a2).
+
+  Constructs an Inception v2 network from inputs to the given final endpoint.
+  This method can construct the network up to the layer inception(5b) as
+  described in http://arxiv.org/abs/1502.03167.
+
+  Args:
+    inputs: a tensor of shape [batch_size, height, width, channels].
+    final_endpoint: specifies the endpoint to construct the network up to. It
+      can be one of ['Conv2d_1a_7x7', 'MaxPool_2a_3x3', 'Conv2d_2b_1x1',
+      'Conv2d_2c_3x3', 'MaxPool_3a_3x3', 'Mixed_3b', 'Mixed_3c', 'Mixed_4a',
+      'Mixed_4b', 'Mixed_4c', 'Mixed_4d', 'Mixed_4e', 'Mixed_5a', 'Mixed_5b',
+      'Mixed_5c'].
+    min_depth: Minimum depth value (number of channels) for all convolution ops.
+      Enforced when depth_multiplier < 1, and not an active constraint when
+      depth_multiplier >= 1.
+    depth_multiplier: Float multiplier for the depth (number of channels)
+      for all convolution ops. The value must be greater than zero. Typical
+      usage will be to set this value in (0, 1) to reduce the number of
+      parameters or computation cost of the model.
+    scope: Optional variable_scope.
+
+  Returns:
+    tensor_out: output tensor corresponding to the final_endpoint.
+    end_points: a set of activations for external use, for example summaries or
+                losses.
+
+  Raises:
+    ValueError: if final_endpoint is not set to one of the predefined values,
+                or depth_multiplier <= 0
+  """
+
+  # end_points will collect relevant activations for external use, for example
+  # summaries or losses.
+  end_points = {}
+
+  # Used to find thinned depths for each layer.
+  if depth_multiplier <= 0:
+    raise ValueError('depth_multiplier is not greater than zero.')
+  depth = lambda d: max(int(d * depth_multiplier), min_depth)
+
+  with tf.variable_scope(scope, 'InceptionV2', [inputs]):
+    with slim.arg_scope(
+        [slim.conv2d, slim.max_pool2d, slim.avg_pool2d, slim.separable_conv2d],
+        stride=1, padding='SAME'):
+
+      # Note that sizes in the comments below assume an input spatial size of
+      # 224x224, however, the inputs can be of any size greater 32x32.
+
+      # 224 x 224 x 3
+      end_point = 'Conv2d_1a_7x7'
+      # depthwise_multiplier here is different from depth_multiplier.
+      # depthwise_multiplier determines the output channels of the initial
+      # depthwise conv (see docs for tf.nn.separable_conv2d), while
+      # depth_multiplier controls the # channels of the subsequent 1x1
+      # convolution. Must have
+      #   in_channels * depthwise_multipler <= out_channels
+      # so that the separable convolution is not overparameterized.
+      depthwise_multiplier = min(int(depth(64) / 3), 8)
+      net = slim.separable_conv2d(
+          inputs, depth(64), [7, 7], depth_multiplier=depthwise_multiplier,
+          stride=2, weights_initializer=trunc_normal(1.0),
+          scope=end_point)
+      end_points[end_point] = net
+      if end_point == final_endpoint: return net, end_points
+      # 112 x 112 x 64
+      end_point = 'MaxPool_2a_3x3'
+      net = slim.max_pool2d(net, [3, 3], scope=end_point, stride=2)
+      end_points[end_point] = net
+      if end_point == final_endpoint: return net, end_points
+      # 56 x 56 x 64
+      end_point = 'Conv2d_2b_1x1'
+      net = slim.conv2d(net, depth(64), [1, 1], scope=end_point,
+                        weights_initializer=trunc_normal(0.1))
+      end_points[end_point] = net
+      if end_point == final_endpoint: return net, end_points
+      # 56 x 56 x 64
+      end_point = 'Conv2d_2c_3x3'
+      net = slim.conv2d(net, depth(192), [3, 3], scope=end_point)
+      end_points[end_point] = net
+      if end_point == final_endpoint: return net, end_points
+      # 56 x 56 x 192
+      end_point = 'MaxPool_3a_3x3'
+      net = slim.max_pool2d(net, [3, 3], scope=end_point, stride=2)
+      end_points[end_point] = net
+      if end_point == final_endpoint: return net, end_points
+      # 28 x 28 x 192
+      # Inception module.
+      end_point = 'Mixed_3b'
+      with tf.variable_scope(end_point):
+        with tf.variable_scope('Branch_0'):
+          branch_0 = slim.conv2d(net, depth(64), [1, 1], scope='Conv2d_0a_1x1')
+        with tf.variable_scope('Branch_1'):
+          branch_1 = slim.conv2d(
+              net, depth(64), [1, 1],
+              weights_initializer=trunc_normal(0.09),
+              scope='Conv2d_0a_1x1')
+          branch_1 = slim.conv2d(branch_1, depth(64), [3, 3],
+                                 scope='Conv2d_0b_3x3')
+        with tf.variable_scope('Branch_2'):
+          branch_2 = slim.conv2d(
+              net, depth(64), [1, 1],
+              weights_initializer=trunc_normal(0.09),
+              scope='Conv2d_0a_1x1')
+          branch_2 = slim.conv2d(branch_2, depth(96), [3, 3],
+                                 scope='Conv2d_0b_3x3')
+          branch_2 = slim.conv2d(branch_2, depth(96), [3, 3],
+                                 scope='Conv2d_0c_3x3')
+        with tf.variable_scope('Branch_3'):
+          branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
+          branch_3 = slim.conv2d(
+              branch_3, depth(32), [1, 1],
+              weights_initializer=trunc_normal(0.1),
+              scope='Conv2d_0b_1x1')
+        net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+        end_points[end_point] = net
+        if end_point == final_endpoint: return net, end_points
+      # 28 x 28 x 256
+      end_point = 'Mixed_3c'
+      with tf.variable_scope(end_point):
+        with tf.variable_scope('Branch_0'):
+          branch_0 = slim.conv2d(net, depth(64), [1, 1], scope='Conv2d_0a_1x1')
+        with tf.variable_scope('Branch_1'):
+          branch_1 = slim.conv2d(
+              net, depth(64), [1, 1],
+              weights_initializer=trunc_normal(0.09),
+              scope='Conv2d_0a_1x1')
+          branch_1 = slim.conv2d(branch_1, depth(96), [3, 3],
+                                 scope='Conv2d_0b_3x3')
+        with tf.variable_scope('Branch_2'):
+          branch_2 = slim.conv2d(
+              net, depth(64), [1, 1],
+              weights_initializer=trunc_normal(0.09),
+              scope='Conv2d_0a_1x1')
+          branch_2 = slim.conv2d(branch_2, depth(96), [3, 3],
+                                 scope='Conv2d_0b_3x3')
+          branch_2 = slim.conv2d(branch_2, depth(96), [3, 3],
+                                 scope='Conv2d_0c_3x3')
+        with tf.variable_scope('Branch_3'):
+          branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
+          branch_3 = slim.conv2d(
+              branch_3, depth(64), [1, 1],
+              weights_initializer=trunc_normal(0.1),
+              scope='Conv2d_0b_1x1')
+        net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+        end_points[end_point] = net
+        if end_point == final_endpoint: return net, end_points
+      # 28 x 28 x 320
+      end_point = 'Mixed_4a'
+      with tf.variable_scope(end_point):
+        with tf.variable_scope('Branch_0'):
+          branch_0 = slim.conv2d(
+              net, depth(128), [1, 1],
+              weights_initializer=trunc_normal(0.09),
+              scope='Conv2d_0a_1x1')
+          branch_0 = slim.conv2d(branch_0, depth(160), [3, 3], stride=2,
+                                 scope='Conv2d_1a_3x3')
+        with tf.variable_scope('Branch_1'):
+          branch_1 = slim.conv2d(
+              net, depth(64), [1, 1],
+              weights_initializer=trunc_normal(0.09),
+              scope='Conv2d_0a_1x1')
+          branch_1 = slim.conv2d(
+              branch_1, depth(96), [3, 3], scope='Conv2d_0b_3x3')
+          branch_1 = slim.conv2d(
+              branch_1, depth(96), [3, 3], stride=2, scope='Conv2d_1a_3x3')
+        with tf.variable_scope('Branch_2'):
+          branch_2 = slim.max_pool2d(
+              net, [3, 3], stride=2, scope='MaxPool_1a_3x3')
+        net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2])
+        end_points[end_point] = net
+        if end_point == final_endpoint: return net, end_points
+      # 14 x 14 x 576
+      end_point = 'Mixed_4b'
+      with tf.variable_scope(end_point):
+        with tf.variable_scope('Branch_0'):
+          branch_0 = slim.conv2d(net, depth(224), [1, 1], scope='Conv2d_0a_1x1')
+        with tf.variable_scope('Branch_1'):
+          branch_1 = slim.conv2d(
+              net, depth(64), [1, 1],
+              weights_initializer=trunc_normal(0.09),
+              scope='Conv2d_0a_1x1')
+          branch_1 = slim.conv2d(
+              branch_1, depth(96), [3, 3], scope='Conv2d_0b_3x3')
+        with tf.variable_scope('Branch_2'):
+          branch_2 = slim.conv2d(
+              net, depth(96), [1, 1],
+              weights_initializer=trunc_normal(0.09),
+              scope='Conv2d_0a_1x1')
+          branch_2 = slim.conv2d(branch_2, depth(128), [3, 3],
+                                 scope='Conv2d_0b_3x3')
+          branch_2 = slim.conv2d(branch_2, depth(128), [3, 3],
+                                 scope='Conv2d_0c_3x3')
+        with tf.variable_scope('Branch_3'):
+          branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
+          branch_3 = slim.conv2d(
+              branch_3, depth(128), [1, 1],
+              weights_initializer=trunc_normal(0.1),
+              scope='Conv2d_0b_1x1')
+        net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+        end_points[end_point] = net
+        if end_point == final_endpoint: return net, end_points
+      # 14 x 14 x 576
+      end_point = 'Mixed_4c'
+      with tf.variable_scope(end_point):
+        with tf.variable_scope('Branch_0'):
+          branch_0 = slim.conv2d(net, depth(192), [1, 1], scope='Conv2d_0a_1x1')
+        with tf.variable_scope('Branch_1'):
+          branch_1 = slim.conv2d(
+              net, depth(96), [1, 1],
+              weights_initializer=trunc_normal(0.09),
+              scope='Conv2d_0a_1x1')
+          branch_1 = slim.conv2d(branch_1, depth(128), [3, 3],
+                                 scope='Conv2d_0b_3x3')
+        with tf.variable_scope('Branch_2'):
+          branch_2 = slim.conv2d(
+              net, depth(96), [1, 1],
+              weights_initializer=trunc_normal(0.09),
+              scope='Conv2d_0a_1x1')
+          branch_2 = slim.conv2d(branch_2, depth(128), [3, 3],
+                                 scope='Conv2d_0b_3x3')
+          branch_2 = slim.conv2d(branch_2, depth(128), [3, 3],
+                                 scope='Conv2d_0c_3x3')
+        with tf.variable_scope('Branch_3'):
+          branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
+          branch_3 = slim.conv2d(
+              branch_3, depth(128), [1, 1],
+              weights_initializer=trunc_normal(0.1),
+              scope='Conv2d_0b_1x1')
+        net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+        end_points[end_point] = net
+        if end_point == final_endpoint: return net, end_points
+      # 14 x 14 x 576
+      end_point = 'Mixed_4d'
+      with tf.variable_scope(end_point):
+        with tf.variable_scope('Branch_0'):
+          branch_0 = slim.conv2d(net, depth(160), [1, 1], scope='Conv2d_0a_1x1')
+        with tf.variable_scope('Branch_1'):
+          branch_1 = slim.conv2d(
+              net, depth(128), [1, 1],
+              weights_initializer=trunc_normal(0.09),
+              scope='Conv2d_0a_1x1')
+          branch_1 = slim.conv2d(branch_1, depth(160), [3, 3],
+                                 scope='Conv2d_0b_3x3')
+        with tf.variable_scope('Branch_2'):
+          branch_2 = slim.conv2d(
+              net, depth(128), [1, 1],
+              weights_initializer=trunc_normal(0.09),
+              scope='Conv2d_0a_1x1')
+          branch_2 = slim.conv2d(branch_2, depth(160), [3, 3],
+                                 scope='Conv2d_0b_3x3')
+          branch_2 = slim.conv2d(branch_2, depth(160), [3, 3],
+                                 scope='Conv2d_0c_3x3')
+        with tf.variable_scope('Branch_3'):
+          branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
+          branch_3 = slim.conv2d(
+              branch_3, depth(96), [1, 1],
+              weights_initializer=trunc_normal(0.1),
+              scope='Conv2d_0b_1x1')
+        net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+        end_points[end_point] = net
+        if end_point == final_endpoint: return net, end_points
+
+      # 14 x 14 x 576
+      end_point = 'Mixed_4e'
+      with tf.variable_scope(end_point):
+        with tf.variable_scope('Branch_0'):
+          branch_0 = slim.conv2d(net, depth(96), [1, 1], scope='Conv2d_0a_1x1')
+        with tf.variable_scope('Branch_1'):
+          branch_1 = slim.conv2d(
+              net, depth(128), [1, 1],
+              weights_initializer=trunc_normal(0.09),
+              scope='Conv2d_0a_1x1')
+          branch_1 = slim.conv2d(branch_1, depth(192), [3, 3],
+                                 scope='Conv2d_0b_3x3')
+        with tf.variable_scope('Branch_2'):
+          branch_2 = slim.conv2d(
+              net, depth(160), [1, 1],
+              weights_initializer=trunc_normal(0.09),
+              scope='Conv2d_0a_1x1')
+          branch_2 = slim.conv2d(branch_2, depth(192), [3, 3],
+                                 scope='Conv2d_0b_3x3')
+          branch_2 = slim.conv2d(branch_2, depth(192), [3, 3],
+                                 scope='Conv2d_0c_3x3')
+        with tf.variable_scope('Branch_3'):
+          branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
+          branch_3 = slim.conv2d(
+              branch_3, depth(96), [1, 1],
+              weights_initializer=trunc_normal(0.1),
+              scope='Conv2d_0b_1x1')
+        net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+        end_points[end_point] = net
+        if end_point == final_endpoint: return net, end_points
+      # 14 x 14 x 576
+      end_point = 'Mixed_5a'
+      with tf.variable_scope(end_point):
+        with tf.variable_scope('Branch_0'):
+          branch_0 = slim.conv2d(
+              net, depth(128), [1, 1],
+              weights_initializer=trunc_normal(0.09),
+              scope='Conv2d_0a_1x1')
+          branch_0 = slim.conv2d(branch_0, depth(192), [3, 3], stride=2,
+                                 scope='Conv2d_1a_3x3')
+        with tf.variable_scope('Branch_1'):
+          branch_1 = slim.conv2d(
+              net, depth(192), [1, 1],
+              weights_initializer=trunc_normal(0.09),
+              scope='Conv2d_0a_1x1')
+          branch_1 = slim.conv2d(branch_1, depth(256), [3, 3],
+                                 scope='Conv2d_0b_3x3')
+          branch_1 = slim.conv2d(branch_1, depth(256), [3, 3], stride=2,
+                                 scope='Conv2d_1a_3x3')
+        with tf.variable_scope('Branch_2'):
+          branch_2 = slim.max_pool2d(net, [3, 3], stride=2,
+                                     scope='MaxPool_1a_3x3')
+        net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2])
+        end_points[end_point] = net
+        if end_point == final_endpoint: return net, end_points
+      # 7 x 7 x 1024
+      end_point = 'Mixed_5b'
+      with tf.variable_scope(end_point):
+        with tf.variable_scope('Branch_0'):
+          branch_0 = slim.conv2d(net, depth(352), [1, 1], scope='Conv2d_0a_1x1')
+        with tf.variable_scope('Branch_1'):
+          branch_1 = slim.conv2d(
+              net, depth(192), [1, 1],
+              weights_initializer=trunc_normal(0.09),
+              scope='Conv2d_0a_1x1')
+          branch_1 = slim.conv2d(branch_1, depth(320), [3, 3],
+                                 scope='Conv2d_0b_3x3')
+        with tf.variable_scope('Branch_2'):
+          branch_2 = slim.conv2d(
+              net, depth(160), [1, 1],
+              weights_initializer=trunc_normal(0.09),
+              scope='Conv2d_0a_1x1')
+          branch_2 = slim.conv2d(branch_2, depth(224), [3, 3],
+                                 scope='Conv2d_0b_3x3')
+          branch_2 = slim.conv2d(branch_2, depth(224), [3, 3],
+                                 scope='Conv2d_0c_3x3')
+        with tf.variable_scope('Branch_3'):
+          branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
+          branch_3 = slim.conv2d(
+              branch_3, depth(128), [1, 1],
+              weights_initializer=trunc_normal(0.1),
+              scope='Conv2d_0b_1x1')
+        net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+        end_points[end_point] = net
+        if end_point == final_endpoint: return net, end_points
+
+      # 7 x 7 x 1024
+      end_point = 'Mixed_5c'
+      with tf.variable_scope(end_point):
+        with tf.variable_scope('Branch_0'):
+          branch_0 = slim.conv2d(net, depth(352), [1, 1], scope='Conv2d_0a_1x1')
+        with tf.variable_scope('Branch_1'):
+          branch_1 = slim.conv2d(
+              net, depth(192), [1, 1],
+              weights_initializer=trunc_normal(0.09),
+              scope='Conv2d_0a_1x1')
+          branch_1 = slim.conv2d(branch_1, depth(320), [3, 3],
+                                 scope='Conv2d_0b_3x3')
+        with tf.variable_scope('Branch_2'):
+          branch_2 = slim.conv2d(
+              net, depth(192), [1, 1],
+              weights_initializer=trunc_normal(0.09),
+              scope='Conv2d_0a_1x1')
+          branch_2 = slim.conv2d(branch_2, depth(224), [3, 3],
+                                 scope='Conv2d_0b_3x3')
+          branch_2 = slim.conv2d(branch_2, depth(224), [3, 3],
+                                 scope='Conv2d_0c_3x3')
+        with tf.variable_scope('Branch_3'):
+          branch_3 = slim.max_pool2d(net, [3, 3], scope='MaxPool_0a_3x3')
+          branch_3 = slim.conv2d(
+              branch_3, depth(128), [1, 1],
+              weights_initializer=trunc_normal(0.1),
+              scope='Conv2d_0b_1x1')
+        net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+        end_points[end_point] = net
+        if end_point == final_endpoint: return net, end_points
+    raise ValueError('Unknown final endpoint %s' % final_endpoint)
+
+
+def inception_v2(inputs,
+                 num_classes=1000,
+                 is_training=True,
+                 dropout_keep_prob=0.8,
+                 min_depth=16,
+                 depth_multiplier=1.0,
+                 prediction_fn=slim.softmax,
+                 spatial_squeeze=True,
+                 reuse=None,
+                 scope='InceptionV2'):
+  """Inception v2 model for classification.
+
+  Constructs an Inception v2 network for classification as described in
+  http://arxiv.org/abs/1502.03167.
+
+  The default image size used to train this network is 224x224.
+
+  Args:
+    inputs: a tensor of shape [batch_size, height, width, channels].
+    num_classes: number of predicted classes.
+    is_training: whether is training or not.
+    dropout_keep_prob: the percentage of activation values that are retained.
+    min_depth: Minimum depth value (number of channels) for all convolution ops.
+      Enforced when depth_multiplier < 1, and not an active constraint when
+      depth_multiplier >= 1.
+    depth_multiplier: Float multiplier for the depth (number of channels)
+      for all convolution ops. The value must be greater than zero. Typical
+      usage will be to set this value in (0, 1) to reduce the number of
+      parameters or computation cost of the model.
+    prediction_fn: a function to get predictions out of logits.
+    spatial_squeeze: if True, logits is of shape [B, C], if false logits is
+        of shape [B, 1, 1, C], where B is batch_size and C is number of classes.
+    reuse: whether or not the network and its variables should be reused. To be
+      able to reuse 'scope' must be given.
+    scope: Optional variable_scope.
+
+  Returns:
+    logits: the pre-softmax activations, a tensor of size
+      [batch_size, num_classes]
+    end_points: a dictionary from components of the network to the corresponding
+      activation.
+
+  Raises:
+    ValueError: if final_endpoint is not set to one of the predefined values,
+                or depth_multiplier <= 0
+  """
+  if depth_multiplier <= 0:
+    raise ValueError('depth_multiplier is not greater than zero.')
+
+  # Final pooling and prediction
+  with tf.variable_scope(scope, 'InceptionV2', [inputs, num_classes],
+                         reuse=reuse) as scope:
+    with slim.arg_scope([slim.batch_norm, slim.dropout],
+                        is_training=is_training):
+      net, end_points = inception_v2_base(
+          inputs, scope=scope, min_depth=min_depth,
+          depth_multiplier=depth_multiplier)
+      with tf.variable_scope('Logits'):
+        kernel_size = _reduced_kernel_size_for_small_input(net, [7, 7])
+        net = slim.avg_pool2d(net, kernel_size, padding='VALID',
+                              scope='AvgPool_1a_{}x{}'.format(*kernel_size))
+        # 1 x 1 x 1024
+        net = slim.dropout(net, keep_prob=dropout_keep_prob, scope='Dropout_1b')
+        logits = slim.conv2d(net, num_classes, [1, 1], activation_fn=None,
+                             normalizer_fn=None, scope='Conv2d_1c_1x1')
+        if spatial_squeeze:
+          logits = tf.squeeze(logits, [1, 2], name='SpatialSqueeze')
+      end_points['Logits'] = logits
+      end_points['Predictions'] = prediction_fn(logits, scope='Predictions')
+  return logits, end_points
+inception_v2.default_image_size = 224
+
+
+def _reduced_kernel_size_for_small_input(input_tensor, kernel_size):
+  """Define kernel size which is automatically reduced for small input.
+
+  If the shape of the input images is unknown at graph construction time this
+  function assumes that the input images are is large enough.
+
+  Args:
+    input_tensor: input tensor of size [batch_size, height, width, channels].
+    kernel_size: desired kernel size of length 2: [kernel_height, kernel_width]
+
+  Returns:
+    a tensor with the kernel size.
+
+  TODO(jrru): Make this function work with unknown shapes. Theoretically, this
+  can be done with the code below. Problems are two-fold: (1) If the shape was
+  known, it will be lost. (2) inception.slim.ops._two_element_tuple cannot
+  handle tensors that define the kernel size.
+      shape = tf.shape(input_tensor)
+      return = tf.pack([tf.minimum(shape[1], kernel_size[0]),
+                        tf.minimum(shape[2], kernel_size[1])])
+
+  """
+  shape = input_tensor.get_shape().as_list()
+  if shape[1] is None or shape[2] is None:
+    kernel_size_out = kernel_size
+  else:
+    kernel_size_out = [min(shape[1], kernel_size[0]),
+                       min(shape[2], kernel_size[1])]
+  return kernel_size_out
+
+
+inception_v2_arg_scope = inception_utils.inception_arg_scope
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_v2_test.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_v2_test.py
new file mode 100755
index 0000000..397aa50
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_v2_test.py
@@ -0,0 +1,262 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for slim_nets.inception_v2."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import numpy as np
+import tensorflow as tf
+
+from nets import inception
+
+slim = tf.contrib.slim
+
+
+class InceptionV2Test(tf.test.TestCase):
+
+  def testBuildClassificationNetwork(self):
+    batch_size = 5
+    height, width = 224, 224
+    num_classes = 1000
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    logits, end_points = inception.inception_v2(inputs, num_classes)
+    self.assertTrue(logits.op.name.startswith('InceptionV2/Logits'))
+    self.assertListEqual(logits.get_shape().as_list(),
+                         [batch_size, num_classes])
+    self.assertTrue('Predictions' in end_points)
+    self.assertListEqual(end_points['Predictions'].get_shape().as_list(),
+                         [batch_size, num_classes])
+
+  def testBuildBaseNetwork(self):
+    batch_size = 5
+    height, width = 224, 224
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    mixed_5c, end_points = inception.inception_v2_base(inputs)
+    self.assertTrue(mixed_5c.op.name.startswith('InceptionV2/Mixed_5c'))
+    self.assertListEqual(mixed_5c.get_shape().as_list(),
+                         [batch_size, 7, 7, 1024])
+    expected_endpoints = ['Mixed_3b', 'Mixed_3c', 'Mixed_4a', 'Mixed_4b',
+                          'Mixed_4c', 'Mixed_4d', 'Mixed_4e', 'Mixed_5a',
+                          'Mixed_5b', 'Mixed_5c', 'Conv2d_1a_7x7',
+                          'MaxPool_2a_3x3', 'Conv2d_2b_1x1', 'Conv2d_2c_3x3',
+                          'MaxPool_3a_3x3']
+    self.assertItemsEqual(end_points.keys(), expected_endpoints)
+
+  def testBuildOnlyUptoFinalEndpoint(self):
+    batch_size = 5
+    height, width = 224, 224
+    endpoints = ['Conv2d_1a_7x7', 'MaxPool_2a_3x3', 'Conv2d_2b_1x1',
+                 'Conv2d_2c_3x3', 'MaxPool_3a_3x3', 'Mixed_3b', 'Mixed_3c',
+                 'Mixed_4a', 'Mixed_4b', 'Mixed_4c', 'Mixed_4d', 'Mixed_4e',
+                 'Mixed_5a', 'Mixed_5b', 'Mixed_5c']
+    for index, endpoint in enumerate(endpoints):
+      with tf.Graph().as_default():
+        inputs = tf.random_uniform((batch_size, height, width, 3))
+        out_tensor, end_points = inception.inception_v2_base(
+            inputs, final_endpoint=endpoint)
+        self.assertTrue(out_tensor.op.name.startswith(
+            'InceptionV2/' + endpoint))
+        self.assertItemsEqual(endpoints[:index+1], end_points)
+
+  def testBuildAndCheckAllEndPointsUptoMixed5c(self):
+    batch_size = 5
+    height, width = 224, 224
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    _, end_points = inception.inception_v2_base(inputs,
+                                                final_endpoint='Mixed_5c')
+    endpoints_shapes = {'Mixed_3b': [batch_size, 28, 28, 256],
+                        'Mixed_3c': [batch_size, 28, 28, 320],
+                        'Mixed_4a': [batch_size, 14, 14, 576],
+                        'Mixed_4b': [batch_size, 14, 14, 576],
+                        'Mixed_4c': [batch_size, 14, 14, 576],
+                        'Mixed_4d': [batch_size, 14, 14, 576],
+                        'Mixed_4e': [batch_size, 14, 14, 576],
+                        'Mixed_5a': [batch_size, 7, 7, 1024],
+                        'Mixed_5b': [batch_size, 7, 7, 1024],
+                        'Mixed_5c': [batch_size, 7, 7, 1024],
+                        'Conv2d_1a_7x7': [batch_size, 112, 112, 64],
+                        'MaxPool_2a_3x3': [batch_size, 56, 56, 64],
+                        'Conv2d_2b_1x1': [batch_size, 56, 56, 64],
+                        'Conv2d_2c_3x3': [batch_size, 56, 56, 192],
+                        'MaxPool_3a_3x3': [batch_size, 28, 28, 192]}
+    self.assertItemsEqual(endpoints_shapes.keys(), end_points.keys())
+    for endpoint_name in endpoints_shapes:
+      expected_shape = endpoints_shapes[endpoint_name]
+      self.assertTrue(endpoint_name in end_points)
+      self.assertListEqual(end_points[endpoint_name].get_shape().as_list(),
+                           expected_shape)
+
+  def testModelHasExpectedNumberOfParameters(self):
+    batch_size = 5
+    height, width = 224, 224
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    with slim.arg_scope(inception.inception_v2_arg_scope()):
+      inception.inception_v2_base(inputs)
+    total_params, _ = slim.model_analyzer.analyze_vars(
+        slim.get_model_variables())
+    self.assertAlmostEqual(10173112, total_params)
+
+  def testBuildEndPointsWithDepthMultiplierLessThanOne(self):
+    batch_size = 5
+    height, width = 224, 224
+    num_classes = 1000
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    _, end_points = inception.inception_v2(inputs, num_classes)
+
+    endpoint_keys = [key for key in end_points.keys()
+                     if key.startswith('Mixed') or key.startswith('Conv')]
+
+    _, end_points_with_multiplier = inception.inception_v2(
+        inputs, num_classes, scope='depth_multiplied_net',
+        depth_multiplier=0.5)
+
+    for key in endpoint_keys:
+      original_depth = end_points[key].get_shape().as_list()[3]
+      new_depth = end_points_with_multiplier[key].get_shape().as_list()[3]
+      self.assertEqual(0.5 * original_depth, new_depth)
+
+  def testBuildEndPointsWithDepthMultiplierGreaterThanOne(self):
+    batch_size = 5
+    height, width = 224, 224
+    num_classes = 1000
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    _, end_points = inception.inception_v2(inputs, num_classes)
+
+    endpoint_keys = [key for key in end_points.keys()
+                     if key.startswith('Mixed') or key.startswith('Conv')]
+
+    _, end_points_with_multiplier = inception.inception_v2(
+        inputs, num_classes, scope='depth_multiplied_net',
+        depth_multiplier=2.0)
+
+    for key in endpoint_keys:
+      original_depth = end_points[key].get_shape().as_list()[3]
+      new_depth = end_points_with_multiplier[key].get_shape().as_list()[3]
+      self.assertEqual(2.0 * original_depth, new_depth)
+
+  def testRaiseValueErrorWithInvalidDepthMultiplier(self):
+    batch_size = 5
+    height, width = 224, 224
+    num_classes = 1000
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    with self.assertRaises(ValueError):
+      _ = inception.inception_v2(inputs, num_classes, depth_multiplier=-0.1)
+    with self.assertRaises(ValueError):
+      _ = inception.inception_v2(inputs, num_classes, depth_multiplier=0.0)
+
+  def testHalfSizeImages(self):
+    batch_size = 5
+    height, width = 112, 112
+    num_classes = 1000
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    logits, end_points = inception.inception_v2(inputs, num_classes)
+    self.assertTrue(logits.op.name.startswith('InceptionV2/Logits'))
+    self.assertListEqual(logits.get_shape().as_list(),
+                         [batch_size, num_classes])
+    pre_pool = end_points['Mixed_5c']
+    self.assertListEqual(pre_pool.get_shape().as_list(),
+                         [batch_size, 4, 4, 1024])
+
+  def testUnknownImageShape(self):
+    tf.reset_default_graph()
+    batch_size = 2
+    height, width = 224, 224
+    num_classes = 1000
+    input_np = np.random.uniform(0, 1, (batch_size, height, width, 3))
+    with self.test_session() as sess:
+      inputs = tf.placeholder(tf.float32, shape=(batch_size, None, None, 3))
+      logits, end_points = inception.inception_v2(inputs, num_classes)
+      self.assertTrue(logits.op.name.startswith('InceptionV2/Logits'))
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [batch_size, num_classes])
+      pre_pool = end_points['Mixed_5c']
+      feed_dict = {inputs: input_np}
+      tf.global_variables_initializer().run()
+      pre_pool_out = sess.run(pre_pool, feed_dict=feed_dict)
+      self.assertListEqual(list(pre_pool_out.shape), [batch_size, 7, 7, 1024])
+
+  def testUnknowBatchSize(self):
+    batch_size = 1
+    height, width = 224, 224
+    num_classes = 1000
+
+    inputs = tf.placeholder(tf.float32, (None, height, width, 3))
+    logits, _ = inception.inception_v2(inputs, num_classes)
+    self.assertTrue(logits.op.name.startswith('InceptionV2/Logits'))
+    self.assertListEqual(logits.get_shape().as_list(),
+                         [None, num_classes])
+    images = tf.random_uniform((batch_size, height, width, 3))
+
+    with self.test_session() as sess:
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(logits, {inputs: images.eval()})
+      self.assertEquals(output.shape, (batch_size, num_classes))
+
+  def testEvaluation(self):
+    batch_size = 2
+    height, width = 224, 224
+    num_classes = 1000
+
+    eval_inputs = tf.random_uniform((batch_size, height, width, 3))
+    logits, _ = inception.inception_v2(eval_inputs, num_classes,
+                                       is_training=False)
+    predictions = tf.argmax(logits, 1)
+
+    with self.test_session() as sess:
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(predictions)
+      self.assertEquals(output.shape, (batch_size,))
+
+  def testTrainEvalWithReuse(self):
+    train_batch_size = 5
+    eval_batch_size = 2
+    height, width = 150, 150
+    num_classes = 1000
+
+    train_inputs = tf.random_uniform((train_batch_size, height, width, 3))
+    inception.inception_v2(train_inputs, num_classes)
+    eval_inputs = tf.random_uniform((eval_batch_size, height, width, 3))
+    logits, _ = inception.inception_v2(eval_inputs, num_classes, reuse=True)
+    predictions = tf.argmax(logits, 1)
+
+    with self.test_session() as sess:
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(predictions)
+      self.assertEquals(output.shape, (eval_batch_size,))
+
+  def testLogitsNotSqueezed(self):
+    num_classes = 25
+    images = tf.random_uniform([1, 224, 224, 3])
+    logits, _ = inception.inception_v2(images,
+                                       num_classes=num_classes,
+                                       spatial_squeeze=False)
+
+    with self.test_session() as sess:
+      tf.global_variables_initializer().run()
+      logits_out = sess.run(logits)
+      self.assertListEqual(list(logits_out.shape), [1, 1, 1, num_classes])
+
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_v3.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_v3.py
new file mode 100755
index 0000000..d64bcfd
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_v3.py
@@ -0,0 +1,560 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Contains the definition for inception v3 classification network."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf
+
+from nets import inception_utils
+
+slim = tf.contrib.slim
+trunc_normal = lambda stddev: tf.truncated_normal_initializer(0.0, stddev)
+
+
+def inception_v3_base(inputs,
+                      final_endpoint='Mixed_7c',
+                      min_depth=16,
+                      depth_multiplier=1.0,
+                      scope=None):
+  """Inception model from http://arxiv.org/abs/1512.00567.
+
+  Constructs an Inception v3 network from inputs to the given final endpoint.
+  This method can construct the network up to the final inception block
+  Mixed_7c.
+
+  Note that the names of the layers in the paper do not correspond to the names
+  of the endpoints registered by this function although they build the same
+  network.
+
+  Here is a mapping from the old_names to the new names:
+  Old name          | New name
+  =======================================
+  conv0             | Conv2d_1a_3x3
+  conv1             | Conv2d_2a_3x3
+  conv2             | Conv2d_2b_3x3
+  pool1             | MaxPool_3a_3x3
+  conv3             | Conv2d_3b_1x1
+  conv4             | Conv2d_4a_3x3
+  pool2             | MaxPool_5a_3x3
+  mixed_35x35x256a  | Mixed_5b
+  mixed_35x35x288a  | Mixed_5c
+  mixed_35x35x288b  | Mixed_5d
+  mixed_17x17x768a  | Mixed_6a
+  mixed_17x17x768b  | Mixed_6b
+  mixed_17x17x768c  | Mixed_6c
+  mixed_17x17x768d  | Mixed_6d
+  mixed_17x17x768e  | Mixed_6e
+  mixed_8x8x1280a   | Mixed_7a
+  mixed_8x8x2048a   | Mixed_7b
+  mixed_8x8x2048b   | Mixed_7c
+
+  Args:
+    inputs: a tensor of size [batch_size, height, width, channels].
+    final_endpoint: specifies the endpoint to construct the network up to. It
+      can be one of ['Conv2d_1a_3x3', 'Conv2d_2a_3x3', 'Conv2d_2b_3x3',
+      'MaxPool_3a_3x3', 'Conv2d_3b_1x1', 'Conv2d_4a_3x3', 'MaxPool_5a_3x3',
+      'Mixed_5b', 'Mixed_5c', 'Mixed_5d', 'Mixed_6a', 'Mixed_6b', 'Mixed_6c',
+      'Mixed_6d', 'Mixed_6e', 'Mixed_7a', 'Mixed_7b', 'Mixed_7c'].
+    min_depth: Minimum depth value (number of channels) for all convolution ops.
+      Enforced when depth_multiplier < 1, and not an active constraint when
+      depth_multiplier >= 1.
+    depth_multiplier: Float multiplier for the depth (number of channels)
+      for all convolution ops. The value must be greater than zero. Typical
+      usage will be to set this value in (0, 1) to reduce the number of
+      parameters or computation cost of the model.
+    scope: Optional variable_scope.
+
+  Returns:
+    tensor_out: output tensor corresponding to the final_endpoint.
+    end_points: a set of activations for external use, for example summaries or
+                losses.
+
+  Raises:
+    ValueError: if final_endpoint is not set to one of the predefined values,
+                or depth_multiplier <= 0
+  """
+  # end_points will collect relevant activations for external use, for example
+  # summaries or losses.
+  end_points = {}
+
+  if depth_multiplier <= 0:
+    raise ValueError('depth_multiplier is not greater than zero.')
+  depth = lambda d: max(int(d * depth_multiplier), min_depth)
+
+  with tf.variable_scope(scope, 'InceptionV3', [inputs]):
+    with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d],
+                        stride=1, padding='VALID'):
+      # 299 x 299 x 3
+      end_point = 'Conv2d_1a_3x3'
+      net = slim.conv2d(inputs, depth(32), [3, 3], stride=2, scope=end_point)
+      end_points[end_point] = net
+      if end_point == final_endpoint: return net, end_points
+      # 149 x 149 x 32
+      end_point = 'Conv2d_2a_3x3'
+      net = slim.conv2d(net, depth(32), [3, 3], scope=end_point)
+      end_points[end_point] = net
+      if end_point == final_endpoint: return net, end_points
+      # 147 x 147 x 32
+      end_point = 'Conv2d_2b_3x3'
+      net = slim.conv2d(net, depth(64), [3, 3], padding='SAME', scope=end_point)
+      end_points[end_point] = net
+      if end_point == final_endpoint: return net, end_points
+      # 147 x 147 x 64
+      end_point = 'MaxPool_3a_3x3'
+      net = slim.max_pool2d(net, [3, 3], stride=2, scope=end_point)
+      end_points[end_point] = net
+      if end_point == final_endpoint: return net, end_points
+      # 73 x 73 x 64
+      end_point = 'Conv2d_3b_1x1'
+      net = slim.conv2d(net, depth(80), [1, 1], scope=end_point)
+      end_points[end_point] = net
+      if end_point == final_endpoint: return net, end_points
+      # 73 x 73 x 80.
+      end_point = 'Conv2d_4a_3x3'
+      net = slim.conv2d(net, depth(192), [3, 3], scope=end_point)
+      end_points[end_point] = net
+      if end_point == final_endpoint: return net, end_points
+      # 71 x 71 x 192.
+      end_point = 'MaxPool_5a_3x3'
+      net = slim.max_pool2d(net, [3, 3], stride=2, scope=end_point)
+      end_points[end_point] = net
+      if end_point == final_endpoint: return net, end_points
+      # 35 x 35 x 192.
+
+    # Inception blocks
+    with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d],
+                        stride=1, padding='SAME'):
+      # mixed: 35 x 35 x 256.
+      end_point = 'Mixed_5b'
+      with tf.variable_scope(end_point):
+        with tf.variable_scope('Branch_0'):
+          branch_0 = slim.conv2d(net, depth(64), [1, 1], scope='Conv2d_0a_1x1')
+        with tf.variable_scope('Branch_1'):
+          branch_1 = slim.conv2d(net, depth(48), [1, 1], scope='Conv2d_0a_1x1')
+          branch_1 = slim.conv2d(branch_1, depth(64), [5, 5],
+                                 scope='Conv2d_0b_5x5')
+        with tf.variable_scope('Branch_2'):
+          branch_2 = slim.conv2d(net, depth(64), [1, 1], scope='Conv2d_0a_1x1')
+          branch_2 = slim.conv2d(branch_2, depth(96), [3, 3],
+                                 scope='Conv2d_0b_3x3')
+          branch_2 = slim.conv2d(branch_2, depth(96), [3, 3],
+                                 scope='Conv2d_0c_3x3')
+        with tf.variable_scope('Branch_3'):
+          branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
+          branch_3 = slim.conv2d(branch_3, depth(32), [1, 1],
+                                 scope='Conv2d_0b_1x1')
+        net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+      end_points[end_point] = net
+      if end_point == final_endpoint: return net, end_points
+
+      # mixed_1: 35 x 35 x 288.
+      end_point = 'Mixed_5c'
+      with tf.variable_scope(end_point):
+        with tf.variable_scope('Branch_0'):
+          branch_0 = slim.conv2d(net, depth(64), [1, 1], scope='Conv2d_0a_1x1')
+        with tf.variable_scope('Branch_1'):
+          branch_1 = slim.conv2d(net, depth(48), [1, 1], scope='Conv2d_0b_1x1')
+          branch_1 = slim.conv2d(branch_1, depth(64), [5, 5],
+                                 scope='Conv_1_0c_5x5')
+        with tf.variable_scope('Branch_2'):
+          branch_2 = slim.conv2d(net, depth(64), [1, 1],
+                                 scope='Conv2d_0a_1x1')
+          branch_2 = slim.conv2d(branch_2, depth(96), [3, 3],
+                                 scope='Conv2d_0b_3x3')
+          branch_2 = slim.conv2d(branch_2, depth(96), [3, 3],
+                                 scope='Conv2d_0c_3x3')
+        with tf.variable_scope('Branch_3'):
+          branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
+          branch_3 = slim.conv2d(branch_3, depth(64), [1, 1],
+                                 scope='Conv2d_0b_1x1')
+        net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+      end_points[end_point] = net
+      if end_point == final_endpoint: return net, end_points
+
+      # mixed_2: 35 x 35 x 288.
+      end_point = 'Mixed_5d'
+      with tf.variable_scope(end_point):
+        with tf.variable_scope('Branch_0'):
+          branch_0 = slim.conv2d(net, depth(64), [1, 1], scope='Conv2d_0a_1x1')
+        with tf.variable_scope('Branch_1'):
+          branch_1 = slim.conv2d(net, depth(48), [1, 1], scope='Conv2d_0a_1x1')
+          branch_1 = slim.conv2d(branch_1, depth(64), [5, 5],
+                                 scope='Conv2d_0b_5x5')
+        with tf.variable_scope('Branch_2'):
+          branch_2 = slim.conv2d(net, depth(64), [1, 1], scope='Conv2d_0a_1x1')
+          branch_2 = slim.conv2d(branch_2, depth(96), [3, 3],
+                                 scope='Conv2d_0b_3x3')
+          branch_2 = slim.conv2d(branch_2, depth(96), [3, 3],
+                                 scope='Conv2d_0c_3x3')
+        with tf.variable_scope('Branch_3'):
+          branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
+          branch_3 = slim.conv2d(branch_3, depth(64), [1, 1],
+                                 scope='Conv2d_0b_1x1')
+        net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+      end_points[end_point] = net
+      if end_point == final_endpoint: return net, end_points
+
+      # mixed_3: 17 x 17 x 768.
+      end_point = 'Mixed_6a'
+      with tf.variable_scope(end_point):
+        with tf.variable_scope('Branch_0'):
+          branch_0 = slim.conv2d(net, depth(384), [3, 3], stride=2,
+                                 padding='VALID', scope='Conv2d_1a_1x1')
+        with tf.variable_scope('Branch_1'):
+          branch_1 = slim.conv2d(net, depth(64), [1, 1], scope='Conv2d_0a_1x1')
+          branch_1 = slim.conv2d(branch_1, depth(96), [3, 3],
+                                 scope='Conv2d_0b_3x3')
+          branch_1 = slim.conv2d(branch_1, depth(96), [3, 3], stride=2,
+                                 padding='VALID', scope='Conv2d_1a_1x1')
+        with tf.variable_scope('Branch_2'):
+          branch_2 = slim.max_pool2d(net, [3, 3], stride=2, padding='VALID',
+                                     scope='MaxPool_1a_3x3')
+        net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2])
+      end_points[end_point] = net
+      if end_point == final_endpoint: return net, end_points
+
+      # mixed4: 17 x 17 x 768.
+      end_point = 'Mixed_6b'
+      with tf.variable_scope(end_point):
+        with tf.variable_scope('Branch_0'):
+          branch_0 = slim.conv2d(net, depth(192), [1, 1], scope='Conv2d_0a_1x1')
+        with tf.variable_scope('Branch_1'):
+          branch_1 = slim.conv2d(net, depth(128), [1, 1], scope='Conv2d_0a_1x1')
+          branch_1 = slim.conv2d(branch_1, depth(128), [1, 7],
+                                 scope='Conv2d_0b_1x7')
+          branch_1 = slim.conv2d(branch_1, depth(192), [7, 1],
+                                 scope='Conv2d_0c_7x1')
+        with tf.variable_scope('Branch_2'):
+          branch_2 = slim.conv2d(net, depth(128), [1, 1], scope='Conv2d_0a_1x1')
+          branch_2 = slim.conv2d(branch_2, depth(128), [7, 1],
+                                 scope='Conv2d_0b_7x1')
+          branch_2 = slim.conv2d(branch_2, depth(128), [1, 7],
+                                 scope='Conv2d_0c_1x7')
+          branch_2 = slim.conv2d(branch_2, depth(128), [7, 1],
+                                 scope='Conv2d_0d_7x1')
+          branch_2 = slim.conv2d(branch_2, depth(192), [1, 7],
+                                 scope='Conv2d_0e_1x7')
+        with tf.variable_scope('Branch_3'):
+          branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
+          branch_3 = slim.conv2d(branch_3, depth(192), [1, 1],
+                                 scope='Conv2d_0b_1x1')
+        net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+      end_points[end_point] = net
+      if end_point == final_endpoint: return net, end_points
+
+      # mixed_5: 17 x 17 x 768.
+      end_point = 'Mixed_6c'
+      with tf.variable_scope(end_point):
+        with tf.variable_scope('Branch_0'):
+          branch_0 = slim.conv2d(net, depth(192), [1, 1], scope='Conv2d_0a_1x1')
+        with tf.variable_scope('Branch_1'):
+          branch_1 = slim.conv2d(net, depth(160), [1, 1], scope='Conv2d_0a_1x1')
+          branch_1 = slim.conv2d(branch_1, depth(160), [1, 7],
+                                 scope='Conv2d_0b_1x7')
+          branch_1 = slim.conv2d(branch_1, depth(192), [7, 1],
+                                 scope='Conv2d_0c_7x1')
+        with tf.variable_scope('Branch_2'):
+          branch_2 = slim.conv2d(net, depth(160), [1, 1], scope='Conv2d_0a_1x1')
+          branch_2 = slim.conv2d(branch_2, depth(160), [7, 1],
+                                 scope='Conv2d_0b_7x1')
+          branch_2 = slim.conv2d(branch_2, depth(160), [1, 7],
+                                 scope='Conv2d_0c_1x7')
+          branch_2 = slim.conv2d(branch_2, depth(160), [7, 1],
+                                 scope='Conv2d_0d_7x1')
+          branch_2 = slim.conv2d(branch_2, depth(192), [1, 7],
+                                 scope='Conv2d_0e_1x7')
+        with tf.variable_scope('Branch_3'):
+          branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
+          branch_3 = slim.conv2d(branch_3, depth(192), [1, 1],
+                                 scope='Conv2d_0b_1x1')
+        net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+      end_points[end_point] = net
+      if end_point == final_endpoint: return net, end_points
+      # mixed_6: 17 x 17 x 768.
+      end_point = 'Mixed_6d'
+      with tf.variable_scope(end_point):
+        with tf.variable_scope('Branch_0'):
+          branch_0 = slim.conv2d(net, depth(192), [1, 1], scope='Conv2d_0a_1x1')
+        with tf.variable_scope('Branch_1'):
+          branch_1 = slim.conv2d(net, depth(160), [1, 1], scope='Conv2d_0a_1x1')
+          branch_1 = slim.conv2d(branch_1, depth(160), [1, 7],
+                                 scope='Conv2d_0b_1x7')
+          branch_1 = slim.conv2d(branch_1, depth(192), [7, 1],
+                                 scope='Conv2d_0c_7x1')
+        with tf.variable_scope('Branch_2'):
+          branch_2 = slim.conv2d(net, depth(160), [1, 1], scope='Conv2d_0a_1x1')
+          branch_2 = slim.conv2d(branch_2, depth(160), [7, 1],
+                                 scope='Conv2d_0b_7x1')
+          branch_2 = slim.conv2d(branch_2, depth(160), [1, 7],
+                                 scope='Conv2d_0c_1x7')
+          branch_2 = slim.conv2d(branch_2, depth(160), [7, 1],
+                                 scope='Conv2d_0d_7x1')
+          branch_2 = slim.conv2d(branch_2, depth(192), [1, 7],
+                                 scope='Conv2d_0e_1x7')
+        with tf.variable_scope('Branch_3'):
+          branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
+          branch_3 = slim.conv2d(branch_3, depth(192), [1, 1],
+                                 scope='Conv2d_0b_1x1')
+        net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+      end_points[end_point] = net
+      if end_point == final_endpoint: return net, end_points
+
+      # mixed_7: 17 x 17 x 768.
+      end_point = 'Mixed_6e'
+      with tf.variable_scope(end_point):
+        with tf.variable_scope('Branch_0'):
+          branch_0 = slim.conv2d(net, depth(192), [1, 1], scope='Conv2d_0a_1x1')
+        with tf.variable_scope('Branch_1'):
+          branch_1 = slim.conv2d(net, depth(192), [1, 1], scope='Conv2d_0a_1x1')
+          branch_1 = slim.conv2d(branch_1, depth(192), [1, 7],
+                                 scope='Conv2d_0b_1x7')
+          branch_1 = slim.conv2d(branch_1, depth(192), [7, 1],
+                                 scope='Conv2d_0c_7x1')
+        with tf.variable_scope('Branch_2'):
+          branch_2 = slim.conv2d(net, depth(192), [1, 1], scope='Conv2d_0a_1x1')
+          branch_2 = slim.conv2d(branch_2, depth(192), [7, 1],
+                                 scope='Conv2d_0b_7x1')
+          branch_2 = slim.conv2d(branch_2, depth(192), [1, 7],
+                                 scope='Conv2d_0c_1x7')
+          branch_2 = slim.conv2d(branch_2, depth(192), [7, 1],
+                                 scope='Conv2d_0d_7x1')
+          branch_2 = slim.conv2d(branch_2, depth(192), [1, 7],
+                                 scope='Conv2d_0e_1x7')
+        with tf.variable_scope('Branch_3'):
+          branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
+          branch_3 = slim.conv2d(branch_3, depth(192), [1, 1],
+                                 scope='Conv2d_0b_1x1')
+        net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+      end_points[end_point] = net
+      if end_point == final_endpoint: return net, end_points
+
+      # mixed_8: 8 x 8 x 1280.
+      end_point = 'Mixed_7a'
+      with tf.variable_scope(end_point):
+        with tf.variable_scope('Branch_0'):
+          branch_0 = slim.conv2d(net, depth(192), [1, 1], scope='Conv2d_0a_1x1')
+          branch_0 = slim.conv2d(branch_0, depth(320), [3, 3], stride=2,
+                                 padding='VALID', scope='Conv2d_1a_3x3')
+        with tf.variable_scope('Branch_1'):
+          branch_1 = slim.conv2d(net, depth(192), [1, 1], scope='Conv2d_0a_1x1')
+          branch_1 = slim.conv2d(branch_1, depth(192), [1, 7],
+                                 scope='Conv2d_0b_1x7')
+          branch_1 = slim.conv2d(branch_1, depth(192), [7, 1],
+                                 scope='Conv2d_0c_7x1')
+          branch_1 = slim.conv2d(branch_1, depth(192), [3, 3], stride=2,
+                                 padding='VALID', scope='Conv2d_1a_3x3')
+        with tf.variable_scope('Branch_2'):
+          branch_2 = slim.max_pool2d(net, [3, 3], stride=2, padding='VALID',
+                                     scope='MaxPool_1a_3x3')
+        net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2])
+      end_points[end_point] = net
+      if end_point == final_endpoint: return net, end_points
+      # mixed_9: 8 x 8 x 2048.
+      end_point = 'Mixed_7b'
+      with tf.variable_scope(end_point):
+        with tf.variable_scope('Branch_0'):
+          branch_0 = slim.conv2d(net, depth(320), [1, 1], scope='Conv2d_0a_1x1')
+        with tf.variable_scope('Branch_1'):
+          branch_1 = slim.conv2d(net, depth(384), [1, 1], scope='Conv2d_0a_1x1')
+          branch_1 = tf.concat(axis=3, values=[
+              slim.conv2d(branch_1, depth(384), [1, 3], scope='Conv2d_0b_1x3'),
+              slim.conv2d(branch_1, depth(384), [3, 1], scope='Conv2d_0b_3x1')])
+        with tf.variable_scope('Branch_2'):
+          branch_2 = slim.conv2d(net, depth(448), [1, 1], scope='Conv2d_0a_1x1')
+          branch_2 = slim.conv2d(
+              branch_2, depth(384), [3, 3], scope='Conv2d_0b_3x3')
+          branch_2 = tf.concat(axis=3, values=[
+              slim.conv2d(branch_2, depth(384), [1, 3], scope='Conv2d_0c_1x3'),
+              slim.conv2d(branch_2, depth(384), [3, 1], scope='Conv2d_0d_3x1')])
+        with tf.variable_scope('Branch_3'):
+          branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
+          branch_3 = slim.conv2d(
+              branch_3, depth(192), [1, 1], scope='Conv2d_0b_1x1')
+        net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+      end_points[end_point] = net
+      if end_point == final_endpoint: return net, end_points
+
+      # mixed_10: 8 x 8 x 2048.
+      end_point = 'Mixed_7c'
+      with tf.variable_scope(end_point):
+        with tf.variable_scope('Branch_0'):
+          branch_0 = slim.conv2d(net, depth(320), [1, 1], scope='Conv2d_0a_1x1')
+        with tf.variable_scope('Branch_1'):
+          branch_1 = slim.conv2d(net, depth(384), [1, 1], scope='Conv2d_0a_1x1')
+          branch_1 = tf.concat(axis=3, values=[
+              slim.conv2d(branch_1, depth(384), [1, 3], scope='Conv2d_0b_1x3'),
+              slim.conv2d(branch_1, depth(384), [3, 1], scope='Conv2d_0c_3x1')])
+        with tf.variable_scope('Branch_2'):
+          branch_2 = slim.conv2d(net, depth(448), [1, 1], scope='Conv2d_0a_1x1')
+          branch_2 = slim.conv2d(
+              branch_2, depth(384), [3, 3], scope='Conv2d_0b_3x3')
+          branch_2 = tf.concat(axis=3, values=[
+              slim.conv2d(branch_2, depth(384), [1, 3], scope='Conv2d_0c_1x3'),
+              slim.conv2d(branch_2, depth(384), [3, 1], scope='Conv2d_0d_3x1')])
+        with tf.variable_scope('Branch_3'):
+          branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
+          branch_3 = slim.conv2d(
+              branch_3, depth(192), [1, 1], scope='Conv2d_0b_1x1')
+        net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+      end_points[end_point] = net
+      if end_point == final_endpoint: return net, end_points
+    raise ValueError('Unknown final endpoint %s' % final_endpoint)
+
+
+def inception_v3(inputs,
+                 num_classes=1000,
+                 is_training=True,
+                 dropout_keep_prob=0.8,
+                 min_depth=16,
+                 depth_multiplier=1.0,
+                 prediction_fn=slim.softmax,
+                 spatial_squeeze=True,
+                 reuse=None,
+                 scope='InceptionV3'):
+  """Inception model from http://arxiv.org/abs/1512.00567.
+
+  "Rethinking the Inception Architecture for Computer Vision"
+
+  Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens,
+  Zbigniew Wojna.
+
+  With the default arguments this method constructs the exact model defined in
+  the paper. However, one can experiment with variations of the inception_v3
+  network by changing arguments dropout_keep_prob, min_depth and
+  depth_multiplier.
+
+  The default image size used to train this network is 299x299.
+
+  Args:
+    inputs: a tensor of size [batch_size, height, width, channels].
+    num_classes: number of predicted classes.
+    is_training: whether is training or not.
+    dropout_keep_prob: the percentage of activation values that are retained.
+    min_depth: Minimum depth value (number of channels) for all convolution ops.
+      Enforced when depth_multiplier < 1, and not an active constraint when
+      depth_multiplier >= 1.
+    depth_multiplier: Float multiplier for the depth (number of channels)
+      for all convolution ops. The value must be greater than zero. Typical
+      usage will be to set this value in (0, 1) to reduce the number of
+      parameters or computation cost of the model.
+    prediction_fn: a function to get predictions out of logits.
+    spatial_squeeze: if True, logits is of shape [B, C], if false logits is
+        of shape [B, 1, 1, C], where B is batch_size and C is number of classes.
+    reuse: whether or not the network and its variables should be reused. To be
+      able to reuse 'scope' must be given.
+    scope: Optional variable_scope.
+
+  Returns:
+    logits: the pre-softmax activations, a tensor of size
+      [batch_size, num_classes]
+    end_points: a dictionary from components of the network to the corresponding
+      activation.
+
+  Raises:
+    ValueError: if 'depth_multiplier' is less than or equal to zero.
+  """
+  if depth_multiplier <= 0:
+    raise ValueError('depth_multiplier is not greater than zero.')
+  depth = lambda d: max(int(d * depth_multiplier), min_depth)
+
+  with tf.variable_scope(scope, 'InceptionV3', [inputs, num_classes],
+                         reuse=reuse) as scope:
+    with slim.arg_scope([slim.batch_norm, slim.dropout],
+                        is_training=is_training):
+      net, end_points = inception_v3_base(
+          inputs, scope=scope, min_depth=min_depth,
+          depth_multiplier=depth_multiplier)
+
+      # Auxiliary Head logits
+      with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d],
+                          stride=1, padding='SAME'):
+        aux_logits = end_points['Mixed_6e']
+        with tf.variable_scope('AuxLogits'):
+          aux_logits = slim.avg_pool2d(
+              aux_logits, [5, 5], stride=3, padding='VALID',
+              scope='AvgPool_1a_5x5')
+          aux_logits = slim.conv2d(aux_logits, depth(128), [1, 1],
+                                   scope='Conv2d_1b_1x1')
+
+          # Shape of feature map before the final layer.
+          kernel_size = _reduced_kernel_size_for_small_input(
+              aux_logits, [5, 5])
+          aux_logits = slim.conv2d(
+              aux_logits, depth(768), kernel_size,
+              weights_initializer=trunc_normal(0.01),
+              padding='VALID', scope='Conv2d_2a_{}x{}'.format(*kernel_size))
+          aux_logits = slim.conv2d(
+              aux_logits, num_classes, [1, 1], activation_fn=None,
+              normalizer_fn=None, weights_initializer=trunc_normal(0.001),
+              scope='Conv2d_2b_1x1')
+          if spatial_squeeze:
+            aux_logits = tf.squeeze(aux_logits, [1, 2], name='SpatialSqueeze')
+          end_points['AuxLogits'] = aux_logits
+
+      # Final pooling and prediction
+      with tf.variable_scope('Logits'):
+        kernel_size = _reduced_kernel_size_for_small_input(net, [8, 8])
+        net = slim.avg_pool2d(net, kernel_size, padding='VALID',
+                              scope='AvgPool_1a_{}x{}'.format(*kernel_size))
+        # 1 x 1 x 2048
+        net = slim.dropout(net, keep_prob=dropout_keep_prob, scope='Dropout_1b')
+        end_points['PreLogits'] = net
+        # 2048
+        logits = slim.conv2d(net, num_classes, [1, 1], activation_fn=None,
+                             normalizer_fn=None, scope='Conv2d_1c_1x1')
+        if spatial_squeeze:
+          logits = tf.squeeze(logits, [1, 2], name='SpatialSqueeze')
+        # 1000
+      end_points['Logits'] = logits
+      end_points['Predictions'] = prediction_fn(logits, scope='Predictions')
+  return logits, end_points
+inception_v3.default_image_size = 299
+
+
+def _reduced_kernel_size_for_small_input(input_tensor, kernel_size):
+  """Define kernel size which is automatically reduced for small input.
+
+  If the shape of the input images is unknown at graph construction time this
+  function assumes that the input images are is large enough.
+
+  Args:
+    input_tensor: input tensor of size [batch_size, height, width, channels].
+    kernel_size: desired kernel size of length 2: [kernel_height, kernel_width]
+
+  Returns:
+    a tensor with the kernel size.
+
+  TODO(jrru): Make this function work with unknown shapes. Theoretically, this
+  can be done with the code below. Problems are two-fold: (1) If the shape was
+  known, it will be lost. (2) inception.slim.ops._two_element_tuple cannot
+  handle tensors that define the kernel size.
+      shape = tf.shape(input_tensor)
+      return = tf.pack([tf.minimum(shape[1], kernel_size[0]),
+                        tf.minimum(shape[2], kernel_size[1])])
+
+  """
+  shape = input_tensor.get_shape().as_list()
+  if shape[1] is None or shape[2] is None:
+    kernel_size_out = kernel_size
+  else:
+    kernel_size_out = [min(shape[1], kernel_size[0]),
+                       min(shape[2], kernel_size[1])]
+  return kernel_size_out
+
+
+inception_v3_arg_scope = inception_utils.inception_arg_scope
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_v3_test.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_v3_test.py
new file mode 100755
index 0000000..a6f3c95
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_v3_test.py
@@ -0,0 +1,292 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for slim_nets.inception_v1."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import numpy as np
+import tensorflow as tf
+
+from nets import inception
+
+slim = tf.contrib.slim
+
+
+class InceptionV3Test(tf.test.TestCase):
+
+  def testBuildClassificationNetwork(self):
+    batch_size = 5
+    height, width = 299, 299
+    num_classes = 1000
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    logits, end_points = inception.inception_v3(inputs, num_classes)
+    self.assertTrue(logits.op.name.startswith('InceptionV3/Logits'))
+    self.assertListEqual(logits.get_shape().as_list(),
+                         [batch_size, num_classes])
+    self.assertTrue('Predictions' in end_points)
+    self.assertListEqual(end_points['Predictions'].get_shape().as_list(),
+                         [batch_size, num_classes])
+
+  def testBuildBaseNetwork(self):
+    batch_size = 5
+    height, width = 299, 299
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    final_endpoint, end_points = inception.inception_v3_base(inputs)
+    self.assertTrue(final_endpoint.op.name.startswith(
+        'InceptionV3/Mixed_7c'))
+    self.assertListEqual(final_endpoint.get_shape().as_list(),
+                         [batch_size, 8, 8, 2048])
+    expected_endpoints = ['Conv2d_1a_3x3', 'Conv2d_2a_3x3', 'Conv2d_2b_3x3',
+                          'MaxPool_3a_3x3', 'Conv2d_3b_1x1', 'Conv2d_4a_3x3',
+                          'MaxPool_5a_3x3', 'Mixed_5b', 'Mixed_5c', 'Mixed_5d',
+                          'Mixed_6a', 'Mixed_6b', 'Mixed_6c', 'Mixed_6d',
+                          'Mixed_6e', 'Mixed_7a', 'Mixed_7b', 'Mixed_7c']
+    self.assertItemsEqual(end_points.keys(), expected_endpoints)
+
+  def testBuildOnlyUptoFinalEndpoint(self):
+    batch_size = 5
+    height, width = 299, 299
+    endpoints = ['Conv2d_1a_3x3', 'Conv2d_2a_3x3', 'Conv2d_2b_3x3',
+                 'MaxPool_3a_3x3', 'Conv2d_3b_1x1', 'Conv2d_4a_3x3',
+                 'MaxPool_5a_3x3', 'Mixed_5b', 'Mixed_5c', 'Mixed_5d',
+                 'Mixed_6a', 'Mixed_6b', 'Mixed_6c', 'Mixed_6d',
+                 'Mixed_6e', 'Mixed_7a', 'Mixed_7b', 'Mixed_7c']
+
+    for index, endpoint in enumerate(endpoints):
+      with tf.Graph().as_default():
+        inputs = tf.random_uniform((batch_size, height, width, 3))
+        out_tensor, end_points = inception.inception_v3_base(
+            inputs, final_endpoint=endpoint)
+        self.assertTrue(out_tensor.op.name.startswith(
+            'InceptionV3/' + endpoint))
+        self.assertItemsEqual(endpoints[:index+1], end_points)
+
+  def testBuildAndCheckAllEndPointsUptoMixed7c(self):
+    batch_size = 5
+    height, width = 299, 299
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    _, end_points = inception.inception_v3_base(
+        inputs, final_endpoint='Mixed_7c')
+    endpoints_shapes = {'Conv2d_1a_3x3': [batch_size, 149, 149, 32],
+                        'Conv2d_2a_3x3': [batch_size, 147, 147, 32],
+                        'Conv2d_2b_3x3': [batch_size, 147, 147, 64],
+                        'MaxPool_3a_3x3': [batch_size, 73, 73, 64],
+                        'Conv2d_3b_1x1': [batch_size, 73, 73, 80],
+                        'Conv2d_4a_3x3': [batch_size, 71, 71, 192],
+                        'MaxPool_5a_3x3': [batch_size, 35, 35, 192],
+                        'Mixed_5b': [batch_size, 35, 35, 256],
+                        'Mixed_5c': [batch_size, 35, 35, 288],
+                        'Mixed_5d': [batch_size, 35, 35, 288],
+                        'Mixed_6a': [batch_size, 17, 17, 768],
+                        'Mixed_6b': [batch_size, 17, 17, 768],
+                        'Mixed_6c': [batch_size, 17, 17, 768],
+                        'Mixed_6d': [batch_size, 17, 17, 768],
+                        'Mixed_6e': [batch_size, 17, 17, 768],
+                        'Mixed_7a': [batch_size, 8, 8, 1280],
+                        'Mixed_7b': [batch_size, 8, 8, 2048],
+                        'Mixed_7c': [batch_size, 8, 8, 2048]}
+    self.assertItemsEqual(endpoints_shapes.keys(), end_points.keys())
+    for endpoint_name in endpoints_shapes:
+      expected_shape = endpoints_shapes[endpoint_name]
+      self.assertTrue(endpoint_name in end_points)
+      self.assertListEqual(end_points[endpoint_name].get_shape().as_list(),
+                           expected_shape)
+
+  def testModelHasExpectedNumberOfParameters(self):
+    batch_size = 5
+    height, width = 299, 299
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    with slim.arg_scope(inception.inception_v3_arg_scope()):
+      inception.inception_v3_base(inputs)
+    total_params, _ = slim.model_analyzer.analyze_vars(
+        slim.get_model_variables())
+    self.assertAlmostEqual(21802784, total_params)
+
+  def testBuildEndPoints(self):
+    batch_size = 5
+    height, width = 299, 299
+    num_classes = 1000
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    _, end_points = inception.inception_v3(inputs, num_classes)
+    self.assertTrue('Logits' in end_points)
+    logits = end_points['Logits']
+    self.assertListEqual(logits.get_shape().as_list(),
+                         [batch_size, num_classes])
+    self.assertTrue('AuxLogits' in end_points)
+    aux_logits = end_points['AuxLogits']
+    self.assertListEqual(aux_logits.get_shape().as_list(),
+                         [batch_size, num_classes])
+    self.assertTrue('Mixed_7c' in end_points)
+    pre_pool = end_points['Mixed_7c']
+    self.assertListEqual(pre_pool.get_shape().as_list(),
+                         [batch_size, 8, 8, 2048])
+    self.assertTrue('PreLogits' in end_points)
+    pre_logits = end_points['PreLogits']
+    self.assertListEqual(pre_logits.get_shape().as_list(),
+                         [batch_size, 1, 1, 2048])
+
+  def testBuildEndPointsWithDepthMultiplierLessThanOne(self):
+    batch_size = 5
+    height, width = 299, 299
+    num_classes = 1000
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    _, end_points = inception.inception_v3(inputs, num_classes)
+
+    endpoint_keys = [key for key in end_points.keys()
+                     if key.startswith('Mixed') or key.startswith('Conv')]
+
+    _, end_points_with_multiplier = inception.inception_v3(
+        inputs, num_classes, scope='depth_multiplied_net',
+        depth_multiplier=0.5)
+
+    for key in endpoint_keys:
+      original_depth = end_points[key].get_shape().as_list()[3]
+      new_depth = end_points_with_multiplier[key].get_shape().as_list()[3]
+      self.assertEqual(0.5 * original_depth, new_depth)
+
+  def testBuildEndPointsWithDepthMultiplierGreaterThanOne(self):
+    batch_size = 5
+    height, width = 299, 299
+    num_classes = 1000
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    _, end_points = inception.inception_v3(inputs, num_classes)
+
+    endpoint_keys = [key for key in end_points.keys()
+                     if key.startswith('Mixed') or key.startswith('Conv')]
+
+    _, end_points_with_multiplier = inception.inception_v3(
+        inputs, num_classes, scope='depth_multiplied_net',
+        depth_multiplier=2.0)
+
+    for key in endpoint_keys:
+      original_depth = end_points[key].get_shape().as_list()[3]
+      new_depth = end_points_with_multiplier[key].get_shape().as_list()[3]
+      self.assertEqual(2.0 * original_depth, new_depth)
+
+  def testRaiseValueErrorWithInvalidDepthMultiplier(self):
+    batch_size = 5
+    height, width = 299, 299
+    num_classes = 1000
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    with self.assertRaises(ValueError):
+      _ = inception.inception_v3(inputs, num_classes, depth_multiplier=-0.1)
+    with self.assertRaises(ValueError):
+      _ = inception.inception_v3(inputs, num_classes, depth_multiplier=0.0)
+
+  def testHalfSizeImages(self):
+    batch_size = 5
+    height, width = 150, 150
+    num_classes = 1000
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    logits, end_points = inception.inception_v3(inputs, num_classes)
+    self.assertTrue(logits.op.name.startswith('InceptionV3/Logits'))
+    self.assertListEqual(logits.get_shape().as_list(),
+                         [batch_size, num_classes])
+    pre_pool = end_points['Mixed_7c']
+    self.assertListEqual(pre_pool.get_shape().as_list(),
+                         [batch_size, 3, 3, 2048])
+
+  def testUnknownImageShape(self):
+    tf.reset_default_graph()
+    batch_size = 2
+    height, width = 299, 299
+    num_classes = 1000
+    input_np = np.random.uniform(0, 1, (batch_size, height, width, 3))
+    with self.test_session() as sess:
+      inputs = tf.placeholder(tf.float32, shape=(batch_size, None, None, 3))
+      logits, end_points = inception.inception_v3(inputs, num_classes)
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [batch_size, num_classes])
+      pre_pool = end_points['Mixed_7c']
+      feed_dict = {inputs: input_np}
+      tf.global_variables_initializer().run()
+      pre_pool_out = sess.run(pre_pool, feed_dict=feed_dict)
+      self.assertListEqual(list(pre_pool_out.shape), [batch_size, 8, 8, 2048])
+
+  def testUnknowBatchSize(self):
+    batch_size = 1
+    height, width = 299, 299
+    num_classes = 1000
+
+    inputs = tf.placeholder(tf.float32, (None, height, width, 3))
+    logits, _ = inception.inception_v3(inputs, num_classes)
+    self.assertTrue(logits.op.name.startswith('InceptionV3/Logits'))
+    self.assertListEqual(logits.get_shape().as_list(),
+                         [None, num_classes])
+    images = tf.random_uniform((batch_size, height, width, 3))
+
+    with self.test_session() as sess:
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(logits, {inputs: images.eval()})
+      self.assertEquals(output.shape, (batch_size, num_classes))
+
+  def testEvaluation(self):
+    batch_size = 2
+    height, width = 299, 299
+    num_classes = 1000
+
+    eval_inputs = tf.random_uniform((batch_size, height, width, 3))
+    logits, _ = inception.inception_v3(eval_inputs, num_classes,
+                                       is_training=False)
+    predictions = tf.argmax(logits, 1)
+
+    with self.test_session() as sess:
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(predictions)
+      self.assertEquals(output.shape, (batch_size,))
+
+  def testTrainEvalWithReuse(self):
+    train_batch_size = 5
+    eval_batch_size = 2
+    height, width = 150, 150
+    num_classes = 1000
+
+    train_inputs = tf.random_uniform((train_batch_size, height, width, 3))
+    inception.inception_v3(train_inputs, num_classes)
+    eval_inputs = tf.random_uniform((eval_batch_size, height, width, 3))
+    logits, _ = inception.inception_v3(eval_inputs, num_classes,
+                                       is_training=False, reuse=True)
+    predictions = tf.argmax(logits, 1)
+
+    with self.test_session() as sess:
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(predictions)
+      self.assertEquals(output.shape, (eval_batch_size,))
+
+  def testLogitsNotSqueezed(self):
+    num_classes = 25
+    images = tf.random_uniform([1, 299, 299, 3])
+    logits, _ = inception.inception_v3(images,
+                                       num_classes=num_classes,
+                                       spatial_squeeze=False)
+
+    with self.test_session() as sess:
+      tf.global_variables_initializer().run()
+      logits_out = sess.run(logits)
+      self.assertListEqual(list(logits_out.shape), [1, 1, 1, num_classes])
+
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_v4.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_v4.py
new file mode 100755
index 0000000..b4f07ea
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_v4.py
@@ -0,0 +1,323 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Contains the definition of the Inception V4 architecture.
+
+As described in http://arxiv.org/abs/1602.07261.
+
+  Inception-v4, Inception-ResNet and the Impact of Residual Connections
+    on Learning
+  Christian Szegedy, Sergey Ioffe, Vincent Vanhoucke, Alex Alemi
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf
+
+from nets import inception_utils
+
+slim = tf.contrib.slim
+
+
+def block_inception_a(inputs, scope=None, reuse=None):
+  """Builds Inception-A block for Inception v4 network."""
+  # By default use stride=1 and SAME padding
+  with slim.arg_scope([slim.conv2d, slim.avg_pool2d, slim.max_pool2d],
+                      stride=1, padding='SAME'):
+    with tf.variable_scope(scope, 'BlockInceptionA', [inputs], reuse=reuse):
+      with tf.variable_scope('Branch_0'):
+        branch_0 = slim.conv2d(inputs, 96, [1, 1], scope='Conv2d_0a_1x1')
+      with tf.variable_scope('Branch_1'):
+        branch_1 = slim.conv2d(inputs, 64, [1, 1], scope='Conv2d_0a_1x1')
+        branch_1 = slim.conv2d(branch_1, 96, [3, 3], scope='Conv2d_0b_3x3')
+      with tf.variable_scope('Branch_2'):
+        branch_2 = slim.conv2d(inputs, 64, [1, 1], scope='Conv2d_0a_1x1')
+        branch_2 = slim.conv2d(branch_2, 96, [3, 3], scope='Conv2d_0b_3x3')
+        branch_2 = slim.conv2d(branch_2, 96, [3, 3], scope='Conv2d_0c_3x3')
+      with tf.variable_scope('Branch_3'):
+        branch_3 = slim.avg_pool2d(inputs, [3, 3], scope='AvgPool_0a_3x3')
+        branch_3 = slim.conv2d(branch_3, 96, [1, 1], scope='Conv2d_0b_1x1')
+      return tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+
+
+def block_reduction_a(inputs, scope=None, reuse=None):
+  """Builds Reduction-A block for Inception v4 network."""
+  # By default use stride=1 and SAME padding
+  with slim.arg_scope([slim.conv2d, slim.avg_pool2d, slim.max_pool2d],
+                      stride=1, padding='SAME'):
+    with tf.variable_scope(scope, 'BlockReductionA', [inputs], reuse=reuse):
+      with tf.variable_scope('Branch_0'):
+        branch_0 = slim.conv2d(inputs, 384, [3, 3], stride=2, padding='VALID',
+                               scope='Conv2d_1a_3x3')
+      with tf.variable_scope('Branch_1'):
+        branch_1 = slim.conv2d(inputs, 192, [1, 1], scope='Conv2d_0a_1x1')
+        branch_1 = slim.conv2d(branch_1, 224, [3, 3], scope='Conv2d_0b_3x3')
+        branch_1 = slim.conv2d(branch_1, 256, [3, 3], stride=2,
+                               padding='VALID', scope='Conv2d_1a_3x3')
+      with tf.variable_scope('Branch_2'):
+        branch_2 = slim.max_pool2d(inputs, [3, 3], stride=2, padding='VALID',
+                                   scope='MaxPool_1a_3x3')
+      return tf.concat(axis=3, values=[branch_0, branch_1, branch_2])
+
+
+def block_inception_b(inputs, scope=None, reuse=None):
+  """Builds Inception-B block for Inception v4 network."""
+  # By default use stride=1 and SAME padding
+  with slim.arg_scope([slim.conv2d, slim.avg_pool2d, slim.max_pool2d],
+                      stride=1, padding='SAME'):
+    with tf.variable_scope(scope, 'BlockInceptionB', [inputs], reuse=reuse):
+      with tf.variable_scope('Branch_0'):
+        branch_0 = slim.conv2d(inputs, 384, [1, 1], scope='Conv2d_0a_1x1')
+      with tf.variable_scope('Branch_1'):
+        branch_1 = slim.conv2d(inputs, 192, [1, 1], scope='Conv2d_0a_1x1')
+        branch_1 = slim.conv2d(branch_1, 224, [1, 7], scope='Conv2d_0b_1x7')
+        branch_1 = slim.conv2d(branch_1, 256, [7, 1], scope='Conv2d_0c_7x1')
+      with tf.variable_scope('Branch_2'):
+        branch_2 = slim.conv2d(inputs, 192, [1, 1], scope='Conv2d_0a_1x1')
+        branch_2 = slim.conv2d(branch_2, 192, [7, 1], scope='Conv2d_0b_7x1')
+        branch_2 = slim.conv2d(branch_2, 224, [1, 7], scope='Conv2d_0c_1x7')
+        branch_2 = slim.conv2d(branch_2, 224, [7, 1], scope='Conv2d_0d_7x1')
+        branch_2 = slim.conv2d(branch_2, 256, [1, 7], scope='Conv2d_0e_1x7')
+      with tf.variable_scope('Branch_3'):
+        branch_3 = slim.avg_pool2d(inputs, [3, 3], scope='AvgPool_0a_3x3')
+        branch_3 = slim.conv2d(branch_3, 128, [1, 1], scope='Conv2d_0b_1x1')
+      return tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+
+
+def block_reduction_b(inputs, scope=None, reuse=None):
+  """Builds Reduction-B block for Inception v4 network."""
+  # By default use stride=1 and SAME padding
+  with slim.arg_scope([slim.conv2d, slim.avg_pool2d, slim.max_pool2d],
+                      stride=1, padding='SAME'):
+    with tf.variable_scope(scope, 'BlockReductionB', [inputs], reuse=reuse):
+      with tf.variable_scope('Branch_0'):
+        branch_0 = slim.conv2d(inputs, 192, [1, 1], scope='Conv2d_0a_1x1')
+        branch_0 = slim.conv2d(branch_0, 192, [3, 3], stride=2,
+                               padding='VALID', scope='Conv2d_1a_3x3')
+      with tf.variable_scope('Branch_1'):
+        branch_1 = slim.conv2d(inputs, 256, [1, 1], scope='Conv2d_0a_1x1')
+        branch_1 = slim.conv2d(branch_1, 256, [1, 7], scope='Conv2d_0b_1x7')
+        branch_1 = slim.conv2d(branch_1, 320, [7, 1], scope='Conv2d_0c_7x1')
+        branch_1 = slim.conv2d(branch_1, 320, [3, 3], stride=2,
+                               padding='VALID', scope='Conv2d_1a_3x3')
+      with tf.variable_scope('Branch_2'):
+        branch_2 = slim.max_pool2d(inputs, [3, 3], stride=2, padding='VALID',
+                                   scope='MaxPool_1a_3x3')
+      return tf.concat(axis=3, values=[branch_0, branch_1, branch_2])
+
+
+def block_inception_c(inputs, scope=None, reuse=None):
+  """Builds Inception-C block for Inception v4 network."""
+  # By default use stride=1 and SAME padding
+  with slim.arg_scope([slim.conv2d, slim.avg_pool2d, slim.max_pool2d],
+                      stride=1, padding='SAME'):
+    with tf.variable_scope(scope, 'BlockInceptionC', [inputs], reuse=reuse):
+      with tf.variable_scope('Branch_0'):
+        branch_0 = slim.conv2d(inputs, 256, [1, 1], scope='Conv2d_0a_1x1')
+      with tf.variable_scope('Branch_1'):
+        branch_1 = slim.conv2d(inputs, 384, [1, 1], scope='Conv2d_0a_1x1')
+        branch_1 = tf.concat(axis=3, values=[
+            slim.conv2d(branch_1, 256, [1, 3], scope='Conv2d_0b_1x3'),
+            slim.conv2d(branch_1, 256, [3, 1], scope='Conv2d_0c_3x1')])
+      with tf.variable_scope('Branch_2'):
+        branch_2 = slim.conv2d(inputs, 384, [1, 1], scope='Conv2d_0a_1x1')
+        branch_2 = slim.conv2d(branch_2, 448, [3, 1], scope='Conv2d_0b_3x1')
+        branch_2 = slim.conv2d(branch_2, 512, [1, 3], scope='Conv2d_0c_1x3')
+        branch_2 = tf.concat(axis=3, values=[
+            slim.conv2d(branch_2, 256, [1, 3], scope='Conv2d_0d_1x3'),
+            slim.conv2d(branch_2, 256, [3, 1], scope='Conv2d_0e_3x1')])
+      with tf.variable_scope('Branch_3'):
+        branch_3 = slim.avg_pool2d(inputs, [3, 3], scope='AvgPool_0a_3x3')
+        branch_3 = slim.conv2d(branch_3, 256, [1, 1], scope='Conv2d_0b_1x1')
+      return tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
+
+
+def inception_v4_base(inputs, final_endpoint='Mixed_7d', scope=None):
+  """Creates the Inception V4 network up to the given final endpoint.
+
+  Args:
+    inputs: a 4-D tensor of size [batch_size, height, width, 3].
+    final_endpoint: specifies the endpoint to construct the network up to.
+      It can be one of [ 'Conv2d_1a_3x3', 'Conv2d_2a_3x3', 'Conv2d_2b_3x3',
+      'Mixed_3a', 'Mixed_4a', 'Mixed_5a', 'Mixed_5b', 'Mixed_5c', 'Mixed_5d',
+      'Mixed_5e', 'Mixed_6a', 'Mixed_6b', 'Mixed_6c', 'Mixed_6d', 'Mixed_6e',
+      'Mixed_6f', 'Mixed_6g', 'Mixed_6h', 'Mixed_7a', 'Mixed_7b', 'Mixed_7c',
+      'Mixed_7d']
+    scope: Optional variable_scope.
+
+  Returns:
+    logits: the logits outputs of the model.
+    end_points: the set of end_points from the inception model.
+
+  Raises:
+    ValueError: if final_endpoint is not set to one of the predefined values,
+  """
+  end_points = {}
+
+  def add_and_check_final(name, net):
+    end_points[name] = net
+    return name == final_endpoint
+
+  with tf.variable_scope(scope, 'InceptionV4', [inputs]):
+    with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d],
+                        stride=1, padding='SAME'):
+      # 299 x 299 x 3
+      net = slim.conv2d(inputs, 32, [3, 3], stride=2,
+                        padding='VALID', scope='Conv2d_1a_3x3')
+      if add_and_check_final('Conv2d_1a_3x3', net): return net, end_points
+      # 149 x 149 x 32
+      net = slim.conv2d(net, 32, [3, 3], padding='VALID',
+                        scope='Conv2d_2a_3x3')
+      if add_and_check_final('Conv2d_2a_3x3', net): return net, end_points
+      # 147 x 147 x 32
+      net = slim.conv2d(net, 64, [3, 3], scope='Conv2d_2b_3x3')
+      if add_and_check_final('Conv2d_2b_3x3', net): return net, end_points
+      # 147 x 147 x 64
+      with tf.variable_scope('Mixed_3a'):
+        with tf.variable_scope('Branch_0'):
+          branch_0 = slim.max_pool2d(net, [3, 3], stride=2, padding='VALID',
+                                     scope='MaxPool_0a_3x3')
+        with tf.variable_scope('Branch_1'):
+          branch_1 = slim.conv2d(net, 96, [3, 3], stride=2, padding='VALID',
+                                 scope='Conv2d_0a_3x3')
+        net = tf.concat(axis=3, values=[branch_0, branch_1])
+        if add_and_check_final('Mixed_3a', net): return net, end_points
+
+      # 73 x 73 x 160
+      with tf.variable_scope('Mixed_4a'):
+        with tf.variable_scope('Branch_0'):
+          branch_0 = slim.conv2d(net, 64, [1, 1], scope='Conv2d_0a_1x1')
+          branch_0 = slim.conv2d(branch_0, 96, [3, 3], padding='VALID',
+                                 scope='Conv2d_1a_3x3')
+        with tf.variable_scope('Branch_1'):
+          branch_1 = slim.conv2d(net, 64, [1, 1], scope='Conv2d_0a_1x1')
+          branch_1 = slim.conv2d(branch_1, 64, [1, 7], scope='Conv2d_0b_1x7')
+          branch_1 = slim.conv2d(branch_1, 64, [7, 1], scope='Conv2d_0c_7x1')
+          branch_1 = slim.conv2d(branch_1, 96, [3, 3], padding='VALID',
+                                 scope='Conv2d_1a_3x3')
+        net = tf.concat(axis=3, values=[branch_0, branch_1])
+        if add_and_check_final('Mixed_4a', net): return net, end_points
+
+      # 71 x 71 x 192
+      with tf.variable_scope('Mixed_5a'):
+        with tf.variable_scope('Branch_0'):
+          branch_0 = slim.conv2d(net, 192, [3, 3], stride=2, padding='VALID',
+                                 scope='Conv2d_1a_3x3')
+        with tf.variable_scope('Branch_1'):
+          branch_1 = slim.max_pool2d(net, [3, 3], stride=2, padding='VALID',
+                                     scope='MaxPool_1a_3x3')
+        net = tf.concat(axis=3, values=[branch_0, branch_1])
+        if add_and_check_final('Mixed_5a', net): return net, end_points
+
+      # 35 x 35 x 384
+      # 4 x Inception-A blocks
+      for idx in range(4):
+        block_scope = 'Mixed_5' + chr(ord('b') + idx)
+        net = block_inception_a(net, block_scope)
+        if add_and_check_final(block_scope, net): return net, end_points
+
+      # 35 x 35 x 384
+      # Reduction-A block
+      net = block_reduction_a(net, 'Mixed_6a')
+      if add_and_check_final('Mixed_6a', net): return net, end_points
+
+      # 17 x 17 x 1024
+      # 7 x Inception-B blocks
+      for idx in range(7):
+        block_scope = 'Mixed_6' + chr(ord('b') + idx)
+        net = block_inception_b(net, block_scope)
+        if add_and_check_final(block_scope, net): return net, end_points
+
+      # 17 x 17 x 1024
+      # Reduction-B block
+      net = block_reduction_b(net, 'Mixed_7a')
+      if add_and_check_final('Mixed_7a', net): return net, end_points
+
+      # 8 x 8 x 1536
+      # 3 x Inception-C blocks
+      for idx in range(3):
+        block_scope = 'Mixed_7' + chr(ord('b') + idx)
+        net = block_inception_c(net, block_scope)
+        if add_and_check_final(block_scope, net): return net, end_points
+  raise ValueError('Unknown final endpoint %s' % final_endpoint)
+
+
+def inception_v4(inputs, num_classes=1001, is_training=True,
+                 dropout_keep_prob=0.8,
+                 reuse=None,
+                 scope='InceptionV4',
+                 create_aux_logits=True):
+  """Creates the Inception V4 model.
+
+  Args:
+    inputs: a 4-D tensor of size [batch_size, height, width, 3].
+    num_classes: number of predicted classes.
+    is_training: whether is training or not.
+    dropout_keep_prob: float, the fraction to keep before final layer.
+    reuse: whether or not the network and its variables should be reused. To be
+      able to reuse 'scope' must be given.
+    scope: Optional variable_scope.
+    create_aux_logits: Whether to include the auxiliary logits.
+
+  Returns:
+    logits: the logits outputs of the model.
+    end_points: the set of end_points from the inception model.
+  """
+  end_points = {}
+  with tf.variable_scope(scope, 'InceptionV4', [inputs], reuse=reuse) as scope:
+    with slim.arg_scope([slim.batch_norm, slim.dropout],
+                        is_training=is_training):
+      net, end_points = inception_v4_base(inputs, scope=scope)
+
+      with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d],
+                          stride=1, padding='SAME'):
+        # Auxiliary Head logits
+        if create_aux_logits:
+          with tf.variable_scope('AuxLogits'):
+            # 17 x 17 x 1024
+            aux_logits = end_points['Mixed_6h']
+            aux_logits = slim.avg_pool2d(aux_logits, [5, 5], stride=3,
+                                         padding='VALID',
+                                         scope='AvgPool_1a_5x5')
+            aux_logits = slim.conv2d(aux_logits, 128, [1, 1],
+                                     scope='Conv2d_1b_1x1')
+            aux_logits = slim.conv2d(aux_logits, 768,
+                                     aux_logits.get_shape()[1:3],
+                                     padding='VALID', scope='Conv2d_2a')
+            aux_logits = slim.flatten(aux_logits)
+            aux_logits = slim.fully_connected(aux_logits, num_classes,
+                                              activation_fn=None,
+                                              scope='Aux_logits')
+            end_points['AuxLogits'] = aux_logits
+
+        # Final pooling and prediction
+        with tf.variable_scope('Logits'):
+          # 8 x 8 x 1536
+          net = slim.avg_pool2d(net, net.get_shape()[1:3], padding='VALID',
+                                scope='AvgPool_1a')
+          # 1 x 1 x 1536
+          net = slim.dropout(net, dropout_keep_prob, scope='Dropout_1b')
+          net = slim.flatten(net, scope='PreLogitsFlatten')
+          end_points['PreLogitsFlatten'] = net
+          # 1536
+          logits = slim.fully_connected(net, num_classes, activation_fn=None,
+                                        scope='Logits')
+          end_points['Logits'] = logits
+          end_points['Predictions'] = tf.nn.softmax(logits, name='Predictions')
+    return logits, end_points
+inception_v4.default_image_size = 299
+
+
+inception_v4_arg_scope = inception_utils.inception_arg_scope
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_v4_test.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_v4_test.py
new file mode 100755
index 0000000..11cffb6
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/inception_v4_test.py
@@ -0,0 +1,216 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for slim.inception_v4."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf
+
+from nets import inception
+
+
+class InceptionTest(tf.test.TestCase):
+
+  def testBuildLogits(self):
+    batch_size = 5
+    height, width = 299, 299
+    num_classes = 1000
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    logits, end_points = inception.inception_v4(inputs, num_classes)
+    auxlogits = end_points['AuxLogits']
+    predictions = end_points['Predictions']
+    self.assertTrue(auxlogits.op.name.startswith('InceptionV4/AuxLogits'))
+    self.assertListEqual(auxlogits.get_shape().as_list(),
+                         [batch_size, num_classes])
+    self.assertTrue(logits.op.name.startswith('InceptionV4/Logits'))
+    self.assertListEqual(logits.get_shape().as_list(),
+                         [batch_size, num_classes])
+    self.assertTrue(predictions.op.name.startswith(
+        'InceptionV4/Logits/Predictions'))
+    self.assertListEqual(predictions.get_shape().as_list(),
+                         [batch_size, num_classes])
+
+  def testBuildWithoutAuxLogits(self):
+    batch_size = 5
+    height, width = 299, 299
+    num_classes = 1000
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    logits, endpoints = inception.inception_v4(inputs, num_classes,
+                                               create_aux_logits=False)
+    self.assertFalse('AuxLogits' in endpoints)
+    self.assertTrue(logits.op.name.startswith('InceptionV4/Logits'))
+    self.assertListEqual(logits.get_shape().as_list(),
+                         [batch_size, num_classes])
+
+  def testAllEndPointsShapes(self):
+    batch_size = 5
+    height, width = 299, 299
+    num_classes = 1000
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    _, end_points = inception.inception_v4(inputs, num_classes)
+    endpoints_shapes = {'Conv2d_1a_3x3': [batch_size, 149, 149, 32],
+                        'Conv2d_2a_3x3': [batch_size, 147, 147, 32],
+                        'Conv2d_2b_3x3': [batch_size, 147, 147, 64],
+                        'Mixed_3a': [batch_size, 73, 73, 160],
+                        'Mixed_4a': [batch_size, 71, 71, 192],
+                        'Mixed_5a': [batch_size, 35, 35, 384],
+                        # 4 x Inception-A blocks
+                        'Mixed_5b': [batch_size, 35, 35, 384],
+                        'Mixed_5c': [batch_size, 35, 35, 384],
+                        'Mixed_5d': [batch_size, 35, 35, 384],
+                        'Mixed_5e': [batch_size, 35, 35, 384],
+                        # Reduction-A block
+                        'Mixed_6a': [batch_size, 17, 17, 1024],
+                        # 7 x Inception-B blocks
+                        'Mixed_6b': [batch_size, 17, 17, 1024],
+                        'Mixed_6c': [batch_size, 17, 17, 1024],
+                        'Mixed_6d': [batch_size, 17, 17, 1024],
+                        'Mixed_6e': [batch_size, 17, 17, 1024],
+                        'Mixed_6f': [batch_size, 17, 17, 1024],
+                        'Mixed_6g': [batch_size, 17, 17, 1024],
+                        'Mixed_6h': [batch_size, 17, 17, 1024],
+                        # Reduction-A block
+                        'Mixed_7a': [batch_size, 8, 8, 1536],
+                        # 3 x Inception-C blocks
+                        'Mixed_7b': [batch_size, 8, 8, 1536],
+                        'Mixed_7c': [batch_size, 8, 8, 1536],
+                        'Mixed_7d': [batch_size, 8, 8, 1536],
+                        # Logits and predictions
+                        'AuxLogits': [batch_size, num_classes],
+                        'PreLogitsFlatten': [batch_size, 1536],
+                        'Logits': [batch_size, num_classes],
+                        'Predictions': [batch_size, num_classes]}
+    self.assertItemsEqual(endpoints_shapes.keys(), end_points.keys())
+    for endpoint_name in endpoints_shapes:
+      expected_shape = endpoints_shapes[endpoint_name]
+      self.assertTrue(endpoint_name in end_points)
+      self.assertListEqual(end_points[endpoint_name].get_shape().as_list(),
+                           expected_shape)
+
+  def testBuildBaseNetwork(self):
+    batch_size = 5
+    height, width = 299, 299
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    net, end_points = inception.inception_v4_base(inputs)
+    self.assertTrue(net.op.name.startswith(
+        'InceptionV4/Mixed_7d'))
+    self.assertListEqual(net.get_shape().as_list(), [batch_size, 8, 8, 1536])
+    expected_endpoints = [
+        'Conv2d_1a_3x3', 'Conv2d_2a_3x3', 'Conv2d_2b_3x3', 'Mixed_3a',
+        'Mixed_4a', 'Mixed_5a', 'Mixed_5b', 'Mixed_5c', 'Mixed_5d',
+        'Mixed_5e', 'Mixed_6a', 'Mixed_6b', 'Mixed_6c', 'Mixed_6d',
+        'Mixed_6e', 'Mixed_6f', 'Mixed_6g', 'Mixed_6h', 'Mixed_7a',
+        'Mixed_7b', 'Mixed_7c', 'Mixed_7d']
+    self.assertItemsEqual(end_points.keys(), expected_endpoints)
+    for name, op in end_points.iteritems():
+      self.assertTrue(op.name.startswith('InceptionV4/' + name))
+
+  def testBuildOnlyUpToFinalEndpoint(self):
+    batch_size = 5
+    height, width = 299, 299
+    all_endpoints = [
+        'Conv2d_1a_3x3', 'Conv2d_2a_3x3', 'Conv2d_2b_3x3', 'Mixed_3a',
+        'Mixed_4a', 'Mixed_5a', 'Mixed_5b', 'Mixed_5c', 'Mixed_5d',
+        'Mixed_5e', 'Mixed_6a', 'Mixed_6b', 'Mixed_6c', 'Mixed_6d',
+        'Mixed_6e', 'Mixed_6f', 'Mixed_6g', 'Mixed_6h', 'Mixed_7a',
+        'Mixed_7b', 'Mixed_7c', 'Mixed_7d']
+    for index, endpoint in enumerate(all_endpoints):
+      with tf.Graph().as_default():
+        inputs = tf.random_uniform((batch_size, height, width, 3))
+        out_tensor, end_points = inception.inception_v4_base(
+            inputs, final_endpoint=endpoint)
+        self.assertTrue(out_tensor.op.name.startswith(
+            'InceptionV4/' + endpoint))
+        self.assertItemsEqual(all_endpoints[:index+1], end_points)
+
+  def testVariablesSetDevice(self):
+    batch_size = 5
+    height, width = 299, 299
+    num_classes = 1000
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    # Force all Variables to reside on the device.
+    with tf.variable_scope('on_cpu'), tf.device('/cpu:0'):
+      inception.inception_v4(inputs, num_classes)
+    with tf.variable_scope('on_gpu'), tf.device('/gpu:0'):
+      inception.inception_v4(inputs, num_classes)
+    for v in tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='on_cpu'):
+      self.assertDeviceEqual(v.device, '/cpu:0')
+    for v in tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='on_gpu'):
+      self.assertDeviceEqual(v.device, '/gpu:0')
+
+  def testHalfSizeImages(self):
+    batch_size = 5
+    height, width = 150, 150
+    num_classes = 1000
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    logits, end_points = inception.inception_v4(inputs, num_classes)
+    self.assertTrue(logits.op.name.startswith('InceptionV4/Logits'))
+    self.assertListEqual(logits.get_shape().as_list(),
+                         [batch_size, num_classes])
+    pre_pool = end_points['Mixed_7d']
+    self.assertListEqual(pre_pool.get_shape().as_list(),
+                         [batch_size, 3, 3, 1536])
+
+  def testUnknownBatchSize(self):
+    batch_size = 1
+    height, width = 299, 299
+    num_classes = 1000
+    with self.test_session() as sess:
+      inputs = tf.placeholder(tf.float32, (None, height, width, 3))
+      logits, _ = inception.inception_v4(inputs, num_classes)
+      self.assertTrue(logits.op.name.startswith('InceptionV4/Logits'))
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [None, num_classes])
+      images = tf.random_uniform((batch_size, height, width, 3))
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(logits, {inputs: images.eval()})
+      self.assertEquals(output.shape, (batch_size, num_classes))
+
+  def testEvaluation(self):
+    batch_size = 2
+    height, width = 299, 299
+    num_classes = 1000
+    with self.test_session() as sess:
+      eval_inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, _ = inception.inception_v4(eval_inputs,
+                                         num_classes,
+                                         is_training=False)
+      predictions = tf.argmax(logits, 1)
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(predictions)
+      self.assertEquals(output.shape, (batch_size,))
+
+  def testTrainEvalWithReuse(self):
+    train_batch_size = 5
+    eval_batch_size = 2
+    height, width = 150, 150
+    num_classes = 1000
+    with self.test_session() as sess:
+      train_inputs = tf.random_uniform((train_batch_size, height, width, 3))
+      inception.inception_v4(train_inputs, num_classes)
+      eval_inputs = tf.random_uniform((eval_batch_size, height, width, 3))
+      logits, _ = inception.inception_v4(eval_inputs,
+                                         num_classes,
+                                         is_training=False,
+                                         reuse=True)
+      predictions = tf.argmax(logits, 1)
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(predictions)
+      self.assertEquals(output.shape, (eval_batch_size,))
+
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/lenet.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/lenet.py
new file mode 100755
index 0000000..789d2bd
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/lenet.py
@@ -0,0 +1,93 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Contains a variant of the LeNet model definition."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf
+
+slim = tf.contrib.slim
+
+
+def lenet(images, num_classes=10, is_training=False,
+          dropout_keep_prob=0.5,
+          prediction_fn=slim.softmax,
+          scope='LeNet'):
+  """Creates a variant of the LeNet model.
+
+  Note that since the output is a set of 'logits', the values fall in the
+  interval of (-infinity, infinity). Consequently, to convert the outputs to a
+  probability distribution over the characters, one will need to convert them
+  using the softmax function:
+
+        logits = lenet.lenet(images, is_training=False)
+        probabilities = tf.nn.softmax(logits)
+        predictions = tf.argmax(logits, 1)
+
+  Args:
+    images: A batch of `Tensors` of size [batch_size, height, width, channels].
+    num_classes: the number of classes in the dataset.
+    is_training: specifies whether or not we're currently training the model.
+      This variable will determine the behaviour of the dropout layer.
+    dropout_keep_prob: the percentage of activation values that are retained.
+    prediction_fn: a function to get predictions out of logits.
+    scope: Optional variable_scope.
+
+  Returns:
+    logits: the pre-softmax activations, a tensor of size
+      [batch_size, `num_classes`]
+    end_points: a dictionary from components of the network to the corresponding
+      activation.
+  """
+  end_points = {}
+
+  with tf.variable_scope(scope, 'LeNet', [images, num_classes]):
+    net = slim.conv2d(images, 32, [5, 5], scope='conv1')
+    net = slim.max_pool2d(net, [2, 2], 2, scope='pool1')
+    net = slim.conv2d(net, 64, [5, 5], scope='conv2')
+    net = slim.max_pool2d(net, [2, 2], 2, scope='pool2')
+    net = slim.flatten(net)
+    end_points['Flatten'] = net
+
+    net = slim.fully_connected(net, 1024, scope='fc3')
+    net = slim.dropout(net, dropout_keep_prob, is_training=is_training,
+                       scope='dropout3')
+    logits = slim.fully_connected(net, num_classes, activation_fn=None,
+                                  scope='fc4')
+
+  end_points['Logits'] = logits
+  end_points['Predictions'] = prediction_fn(logits, scope='Predictions')
+
+  return logits, end_points
+lenet.default_image_size = 28
+
+
+def lenet_arg_scope(weight_decay=0.0):
+  """Defines the default lenet argument scope.
+
+  Args:
+    weight_decay: The weight decay to use for regularizing the model.
+
+  Returns:
+    An `arg_scope` to use for the inception v3 model.
+  """
+  with slim.arg_scope(
+      [slim.conv2d, slim.fully_connected],
+      weights_regularizer=slim.l2_regularizer(weight_decay),
+      weights_initializer=tf.truncated_normal_initializer(stddev=0.1),
+      activation_fn=tf.nn.relu) as sc:
+    return sc
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/mobilenet_v1.md b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/mobilenet_v1.md
new file mode 100755
index 0000000..342f305
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/mobilenet_v1.md
@@ -0,0 +1,47 @@
+# MobileNet_v1
+
+[MobileNets](https://arxiv.org/abs/1704.04861) are small, low-latency, low-power models parameterized to meet the resource constraints of a variety of use cases. They can be built upon for classification, detection, embeddings and segmentation similar to how other popular large scale models, such as Inception, are used. MobileNets can be run efficiently on mobile devices with [TensorFlow Mobile](https://www.tensorflow.org/mobile/).
+
+MobileNets trade off between latency, size and accuracy while comparing favorably with popular models from the literature.
+
+![alt text](mobilenet_v1.png "MobileNet Graph")
+
+# Pre-trained Models
+
+Choose the right MobileNet model to fit your latency and size budget. The size of the network in memory and on disk is proportional to the number of parameters. The latency and power usage of the network scales with the number of Multiply-Accumulates (MACs) which measures the number of fused Multiplication and Addition operations. These MobileNet models have been trained on the
+[ILSVRC-2012-CLS](http://www.image-net.org/challenges/LSVRC/2012/)
+image classification dataset. Accuracies were computed by evaluating using a single image crop.
+
+Model Checkpoint | Million MACs | Million Parameters | Top-1 Accuracy| Top-5 Accuracy |
+:----:|:------------:|:----------:|:-------:|:-------:|
+[MobileNet_v1_1.0_224](http://download.tensorflow.org/models/mobilenet_v1_1.0_224_2017_06_14.tar.gz)|569|4.24|70.7|89.5|
+[MobileNet_v1_1.0_192](http://download.tensorflow.org/models/mobilenet_v1_1.0_192_2017_06_14.tar.gz)|418|4.24|69.3|88.9|
+[MobileNet_v1_1.0_160](http://download.tensorflow.org/models/mobilenet_v1_1.0_160_2017_06_14.tar.gz)|291|4.24|67.2|87.5|
+[MobileNet_v1_1.0_128](http://download.tensorflow.org/models/mobilenet_v1_1.0_128_2017_06_14.tar.gz)|186|4.24|64.1|85.3|
+[MobileNet_v1_0.75_224](http://download.tensorflow.org/models/mobilenet_v1_0.75_224_2017_06_14.tar.gz)|317|2.59|68.4|88.2|
+[MobileNet_v1_0.75_192](http://download.tensorflow.org/models/mobilenet_v1_0.75_192_2017_06_14.tar.gz)|233|2.59|67.4|87.3|
+[MobileNet_v1_0.75_160](http://download.tensorflow.org/models/mobilenet_v1_0.75_160_2017_06_14.tar.gz)|162|2.59|65.2|86.1|
+[MobileNet_v1_0.75_128](http://download.tensorflow.org/models/mobilenet_v1_0.75_128_2017_06_14.tar.gz)|104|2.59|61.8|83.6|
+[MobileNet_v1_0.50_224](http://download.tensorflow.org/models/mobilenet_v1_0.50_224_2017_06_14.tar.gz)|150|1.34|64.0|85.4|
+[MobileNet_v1_0.50_192](http://download.tensorflow.org/models/mobilenet_v1_0.50_192_2017_06_14.tar.gz)|110|1.34|62.1|84.0|
+[MobileNet_v1_0.50_160](http://download.tensorflow.org/models/mobilenet_v1_0.50_160_2017_06_14.tar.gz)|77|1.34|59.9|82.5|
+[MobileNet_v1_0.50_128](http://download.tensorflow.org/models/mobilenet_v1_0.50_128_2017_06_14.tar.gz)|49|1.34|56.2|79.6|
+[MobileNet_v1_0.25_224](http://download.tensorflow.org/models/mobilenet_v1_0.25_224_2017_06_14.tar.gz)|41|0.47|50.6|75.0|
+[MobileNet_v1_0.25_192](http://download.tensorflow.org/models/mobilenet_v1_0.25_192_2017_06_14.tar.gz)|34|0.47|49.0|73.6|
+[MobileNet_v1_0.25_160](http://download.tensorflow.org/models/mobilenet_v1_0.25_160_2017_06_14.tar.gz)|21|0.47|46.0|70.7|
+[MobileNet_v1_0.25_128](http://download.tensorflow.org/models/mobilenet_v1_0.25_128_2017_06_14.tar.gz)|14|0.47|41.3|66.2|
+
+
+Here is an example of how to download the MobileNet_v1_1.0_224 checkpoint:
+
+```shell
+$ CHECKPOINT_DIR=/tmp/checkpoints
+$ mkdir ${CHECKPOINT_DIR}
+$ wget http://download.tensorflow.org/models/mobilenet_v1_1.0_224_2017_06_14.tar.gz
+$ tar -xvf mobilenet_v1_1.0_224_2017_06_14.tar.gz
+$ mv mobilenet_v1_1.0_224.ckpt.* ${CHECKPOINT_DIR}
+$ rm mobilenet_v1_1.0_224_2017_06_14.tar.gz
+```
+More information on integrating MobileNets into your project can be found at the [TF-Slim Image Classification Library](https://github.com/tensorflow/models/blob/master/slim/README.md).
+
+To get started running models on-device go to [TensorFlow Mobile](https://www.tensorflow.org/mobile/).
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/mobilenet_v1.png b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/mobilenet_v1.png
new file mode 100755
index 0000000..a458345
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/mobilenet_v1.png differ
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/mobilenet_v1.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/mobilenet_v1.py
new file mode 100755
index 0000000..9b25145
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/mobilenet_v1.py
@@ -0,0 +1,397 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# =============================================================================
+"""MobileNet v1.
+
+MobileNet is a general architecture and can be used for multiple use cases.
+Depending on the use case, it can use different input layer size and different
+head (for example: embeddings, localization and classification).
+
+As described in https://arxiv.org/abs/1704.04861.
+
+  MobileNets: Efficient Convolutional Neural Networks for
+    Mobile Vision Applications
+  Andrew G. Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang,
+    Tobias Weyand, Marco Andreetto, Hartwig Adam
+
+100% Mobilenet V1 (base) with input size 224x224:
+
+Layer                                                     params           macs
+--------------------------------------------------------------------------------
+MobilenetV1/Conv2d_0/Conv2D:                                 864      10,838,016
+MobilenetV1/Conv2d_1_depthwise/depthwise:                    288       3,612,672
+MobilenetV1/Conv2d_1_pointwise/Conv2D:                     2,048      25,690,112
+MobilenetV1/Conv2d_2_depthwise/depthwise:                    576       1,806,336
+MobilenetV1/Conv2d_2_pointwise/Conv2D:                     8,192      25,690,112
+MobilenetV1/Conv2d_3_depthwise/depthwise:                  1,152       3,612,672
+MobilenetV1/Conv2d_3_pointwise/Conv2D:                    16,384      51,380,224
+MobilenetV1/Conv2d_4_depthwise/depthwise:                  1,152         903,168
+MobilenetV1/Conv2d_4_pointwise/Conv2D:                    32,768      25,690,112
+MobilenetV1/Conv2d_5_depthwise/depthwise:                  2,304       1,806,336
+MobilenetV1/Conv2d_5_pointwise/Conv2D:                    65,536      51,380,224
+MobilenetV1/Conv2d_6_depthwise/depthwise:                  2,304         451,584
+MobilenetV1/Conv2d_6_pointwise/Conv2D:                   131,072      25,690,112
+MobilenetV1/Conv2d_7_depthwise/depthwise:                  4,608         903,168
+MobilenetV1/Conv2d_7_pointwise/Conv2D:                   262,144      51,380,224
+MobilenetV1/Conv2d_8_depthwise/depthwise:                  4,608         903,168
+MobilenetV1/Conv2d_8_pointwise/Conv2D:                   262,144      51,380,224
+MobilenetV1/Conv2d_9_depthwise/depthwise:                  4,608         903,168
+MobilenetV1/Conv2d_9_pointwise/Conv2D:                   262,144      51,380,224
+MobilenetV1/Conv2d_10_depthwise/depthwise:                 4,608         903,168
+MobilenetV1/Conv2d_10_pointwise/Conv2D:                  262,144      51,380,224
+MobilenetV1/Conv2d_11_depthwise/depthwise:                 4,608         903,168
+MobilenetV1/Conv2d_11_pointwise/Conv2D:                  262,144      51,380,224
+MobilenetV1/Conv2d_12_depthwise/depthwise:                 4,608         225,792
+MobilenetV1/Conv2d_12_pointwise/Conv2D:                  524,288      25,690,112
+MobilenetV1/Conv2d_13_depthwise/depthwise:                 9,216         451,584
+MobilenetV1/Conv2d_13_pointwise/Conv2D:                1,048,576      51,380,224
+--------------------------------------------------------------------------------
+Total:                                                 3,185,088     567,716,352
+
+
+75% Mobilenet V1 (base) with input size 128x128:
+
+Layer                                                     params           macs
+--------------------------------------------------------------------------------
+MobilenetV1/Conv2d_0/Conv2D:                                 648       2,654,208
+MobilenetV1/Conv2d_1_depthwise/depthwise:                    216         884,736
+MobilenetV1/Conv2d_1_pointwise/Conv2D:                     1,152       4,718,592
+MobilenetV1/Conv2d_2_depthwise/depthwise:                    432         442,368
+MobilenetV1/Conv2d_2_pointwise/Conv2D:                     4,608       4,718,592
+MobilenetV1/Conv2d_3_depthwise/depthwise:                    864         884,736
+MobilenetV1/Conv2d_3_pointwise/Conv2D:                     9,216       9,437,184
+MobilenetV1/Conv2d_4_depthwise/depthwise:                    864         221,184
+MobilenetV1/Conv2d_4_pointwise/Conv2D:                    18,432       4,718,592
+MobilenetV1/Conv2d_5_depthwise/depthwise:                  1,728         442,368
+MobilenetV1/Conv2d_5_pointwise/Conv2D:                    36,864       9,437,184
+MobilenetV1/Conv2d_6_depthwise/depthwise:                  1,728         110,592
+MobilenetV1/Conv2d_6_pointwise/Conv2D:                    73,728       4,718,592
+MobilenetV1/Conv2d_7_depthwise/depthwise:                  3,456         221,184
+MobilenetV1/Conv2d_7_pointwise/Conv2D:                   147,456       9,437,184
+MobilenetV1/Conv2d_8_depthwise/depthwise:                  3,456         221,184
+MobilenetV1/Conv2d_8_pointwise/Conv2D:                   147,456       9,437,184
+MobilenetV1/Conv2d_9_depthwise/depthwise:                  3,456         221,184
+MobilenetV1/Conv2d_9_pointwise/Conv2D:                   147,456       9,437,184
+MobilenetV1/Conv2d_10_depthwise/depthwise:                 3,456         221,184
+MobilenetV1/Conv2d_10_pointwise/Conv2D:                  147,456       9,437,184
+MobilenetV1/Conv2d_11_depthwise/depthwise:                 3,456         221,184
+MobilenetV1/Conv2d_11_pointwise/Conv2D:                  147,456       9,437,184
+MobilenetV1/Conv2d_12_depthwise/depthwise:                 3,456          55,296
+MobilenetV1/Conv2d_12_pointwise/Conv2D:                  294,912       4,718,592
+MobilenetV1/Conv2d_13_depthwise/depthwise:                 6,912         110,592
+MobilenetV1/Conv2d_13_pointwise/Conv2D:                  589,824       9,437,184
+--------------------------------------------------------------------------------
+Total:                                                 1,800,144     106,002,432
+
+"""
+
+# Tensorflow mandates these.
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from collections import namedtuple
+
+import tensorflow as tf
+
+slim = tf.contrib.slim
+
+# Conv and DepthSepConv namedtuple define layers of the MobileNet architecture
+# Conv defines 3x3 convolution layers
+# DepthSepConv defines 3x3 depthwise convolution followed by 1x1 convolution.
+# stride is the stride of the convolution
+# depth is the number of channels or filters in a layer
+Conv = namedtuple('Conv', ['kernel', 'stride', 'depth'])
+DepthSepConv = namedtuple('DepthSepConv', ['kernel', 'stride', 'depth'])
+
+# _CONV_DEFS specifies the MobileNet body
+_CONV_DEFS = [
+    Conv(kernel=[3, 3], stride=2, depth=32),
+    DepthSepConv(kernel=[3, 3], stride=1, depth=64),
+    DepthSepConv(kernel=[3, 3], stride=2, depth=128),
+    DepthSepConv(kernel=[3, 3], stride=1, depth=128),
+    DepthSepConv(kernel=[3, 3], stride=2, depth=256),
+    DepthSepConv(kernel=[3, 3], stride=1, depth=256),
+    DepthSepConv(kernel=[3, 3], stride=2, depth=512),
+    DepthSepConv(kernel=[3, 3], stride=1, depth=512),
+    DepthSepConv(kernel=[3, 3], stride=1, depth=512),
+    DepthSepConv(kernel=[3, 3], stride=1, depth=512),
+    DepthSepConv(kernel=[3, 3], stride=1, depth=512),
+    DepthSepConv(kernel=[3, 3], stride=1, depth=512),
+    DepthSepConv(kernel=[3, 3], stride=2, depth=1024),
+    DepthSepConv(kernel=[3, 3], stride=1, depth=1024)
+]
+
+
+def mobilenet_v1_base(inputs,
+                      final_endpoint='Conv2d_13_pointwise',
+                      min_depth=8,
+                      depth_multiplier=1.0,
+                      conv_defs=None,
+                      output_stride=None,
+                      scope=None):
+  """Mobilenet v1.
+
+  Constructs a Mobilenet v1 network from inputs to the given final endpoint.
+
+  Args:
+    inputs: a tensor of shape [batch_size, height, width, channels].
+    final_endpoint: specifies the endpoint to construct the network up to. It
+      can be one of ['Conv2d_0', 'Conv2d_1_pointwise', 'Conv2d_2_pointwise',
+      'Conv2d_3_pointwise', 'Conv2d_4_pointwise', 'Conv2d_5'_pointwise,
+      'Conv2d_6_pointwise', 'Conv2d_7_pointwise', 'Conv2d_8_pointwise',
+      'Conv2d_9_pointwise', 'Conv2d_10_pointwise', 'Conv2d_11_pointwise',
+      'Conv2d_12_pointwise', 'Conv2d_13_pointwise'].
+    min_depth: Minimum depth value (number of channels) for all convolution ops.
+      Enforced when depth_multiplier < 1, and not an active constraint when
+      depth_multiplier >= 1.
+    depth_multiplier: Float multiplier for the depth (number of channels)
+      for all convolution ops. The value must be greater than zero. Typical
+      usage will be to set this value in (0, 1) to reduce the number of
+      parameters or computation cost of the model.
+    conv_defs: A list of ConvDef namedtuples specifying the net architecture.
+    output_stride: An integer that specifies the requested ratio of input to
+      output spatial resolution. If not None, then we invoke atrous convolution
+      if necessary to prevent the network from reducing the spatial resolution
+      of the activation maps. Allowed values are 8 (accurate fully convolutional
+      mode), 16 (fast fully convolutional mode), 32 (classification mode).
+    scope: Optional variable_scope.
+
+  Returns:
+    tensor_out: output tensor corresponding to the final_endpoint.
+    end_points: a set of activations for external use, for example summaries or
+                losses.
+
+  Raises:
+    ValueError: if final_endpoint is not set to one of the predefined values,
+                or depth_multiplier <= 0, or the target output_stride is not
+                allowed.
+  """
+  depth = lambda d: max(int(d * depth_multiplier), min_depth)
+  end_points = {}
+
+  # Used to find thinned depths for each layer.
+  if depth_multiplier <= 0:
+    raise ValueError('depth_multiplier is not greater than zero.')
+
+  if conv_defs is None:
+    conv_defs = _CONV_DEFS
+
+  if output_stride is not None and output_stride not in [8, 16, 32]:
+    raise ValueError('Only allowed output_stride values are 8, 16, 32.')
+
+  with tf.variable_scope(scope, 'MobilenetV1', [inputs]):
+    with slim.arg_scope([slim.conv2d, slim.separable_conv2d], padding='SAME'):
+      # The current_stride variable keeps track of the output stride of the
+      # activations, i.e., the running product of convolution strides up to the
+      # current network layer. This allows us to invoke atrous convolution
+      # whenever applying the next convolution would result in the activations
+      # having output stride larger than the target output_stride.
+      current_stride = 1
+
+      # The atrous convolution rate parameter.
+      rate = 1
+
+      net = inputs
+      for i, conv_def in enumerate(conv_defs):
+        end_point_base = 'Conv2d_%d' % i
+
+        if output_stride is not None and current_stride == output_stride:
+          # If we have reached the target output_stride, then we need to employ
+          # atrous convolution with stride=1 and multiply the atrous rate by the
+          # current unit's stride for use in subsequent layers.
+          layer_stride = 1
+          layer_rate = rate
+          rate *= conv_def.stride
+        else:
+          layer_stride = conv_def.stride
+          layer_rate = 1
+          current_stride *= conv_def.stride
+
+        if isinstance(conv_def, Conv):
+          end_point = end_point_base
+          net = slim.conv2d(net, depth(conv_def.depth), conv_def.kernel,
+                            stride=conv_def.stride,
+                            normalizer_fn=slim.batch_norm,
+                            scope=end_point)
+          end_points[end_point] = net
+          if end_point == final_endpoint:
+            return net, end_points
+
+        elif isinstance(conv_def, DepthSepConv):
+          end_point = end_point_base + '_depthwise'
+
+          # By passing filters=None
+          # separable_conv2d produces only a depthwise convolution layer
+          net = slim.separable_conv2d(net, None, conv_def.kernel,
+                                      depth_multiplier=1,
+                                      stride=layer_stride,
+                                      rate=layer_rate,
+                                      normalizer_fn=slim.batch_norm,
+                                      scope=end_point)
+
+          end_points[end_point] = net
+          if end_point == final_endpoint:
+            return net, end_points
+
+          end_point = end_point_base + '_pointwise'
+
+          net = slim.conv2d(net, depth(conv_def.depth), [1, 1],
+                            stride=1,
+                            normalizer_fn=slim.batch_norm,
+                            scope=end_point)
+
+          end_points[end_point] = net
+          if end_point == final_endpoint:
+            return net, end_points
+        else:
+          raise ValueError('Unknown convolution type %s for layer %d'
+                           % (conv_def.ltype, i))
+  raise ValueError('Unknown final endpoint %s' % final_endpoint)
+
+
+def mobilenet_v1(inputs,
+                 num_classes=1000,
+                 dropout_keep_prob=0.999,
+                 is_training=True,
+                 min_depth=8,
+                 depth_multiplier=1.0,
+                 conv_defs=None,
+                 prediction_fn=tf.contrib.layers.softmax,
+                 spatial_squeeze=True,
+                 reuse=None,
+                 scope='MobilenetV1'):
+  """Mobilenet v1 model for classification.
+
+  Args:
+    inputs: a tensor of shape [batch_size, height, width, channels].
+    num_classes: number of predicted classes.
+    dropout_keep_prob: the percentage of activation values that are retained.
+    is_training: whether is training or not.
+    min_depth: Minimum depth value (number of channels) for all convolution ops.
+      Enforced when depth_multiplier < 1, and not an active constraint when
+      depth_multiplier >= 1.
+    depth_multiplier: Float multiplier for the depth (number of channels)
+      for all convolution ops. The value must be greater than zero. Typical
+      usage will be to set this value in (0, 1) to reduce the number of
+      parameters or computation cost of the model.
+    conv_defs: A list of ConvDef namedtuples specifying the net architecture.
+    prediction_fn: a function to get predictions out of logits.
+    spatial_squeeze: if True, logits is of shape is [B, C], if false logits is
+        of shape [B, 1, 1, C], where B is batch_size and C is number of classes.
+    reuse: whether or not the network and its variables should be reused. To be
+      able to reuse 'scope' must be given.
+    scope: Optional variable_scope.
+
+  Returns:
+    logits: the pre-softmax activations, a tensor of size
+      [batch_size, num_classes]
+    end_points: a dictionary from components of the network to the corresponding
+      activation.
+
+  Raises:
+    ValueError: Input rank is invalid.
+  """
+  input_shape = inputs.get_shape().as_list()
+  if len(input_shape) != 4:
+    raise ValueError('Invalid input tensor rank, expected 4, was: %d' %
+                     len(input_shape))
+
+  with tf.variable_scope(scope, 'MobilenetV1', [inputs, num_classes],
+                         reuse=reuse) as scope:
+    with slim.arg_scope([slim.batch_norm, slim.dropout],
+                        is_training=is_training):
+      net, end_points = mobilenet_v1_base(inputs, scope=scope,
+                                          min_depth=min_depth,
+                                          depth_multiplier=depth_multiplier,
+                                          conv_defs=conv_defs)
+      with tf.variable_scope('Logits'):
+        kernel_size = _reduced_kernel_size_for_small_input(net, [7, 7])
+        net = slim.avg_pool2d(net, kernel_size, padding='VALID',
+                              scope='AvgPool_1a')
+        end_points['AvgPool_1a'] = net
+        # 1 x 1 x 1024
+        net = slim.dropout(net, keep_prob=dropout_keep_prob, scope='Dropout_1b')
+        logits = slim.conv2d(net, num_classes, [1, 1], activation_fn=None,
+                             normalizer_fn=None, scope='Conv2d_1c_1x1')
+        if spatial_squeeze:
+          logits = tf.squeeze(logits, [1, 2], name='SpatialSqueeze')
+      end_points['Logits'] = logits
+      if prediction_fn:
+        end_points['Predictions'] = prediction_fn(logits, scope='Predictions')
+  return logits, end_points
+
+mobilenet_v1.default_image_size = 224
+
+
+def _reduced_kernel_size_for_small_input(input_tensor, kernel_size):
+  """Define kernel size which is automatically reduced for small input.
+
+  If the shape of the input images is unknown at graph construction time this
+  function assumes that the input images are large enough.
+
+  Args:
+    input_tensor: input tensor of size [batch_size, height, width, channels].
+    kernel_size: desired kernel size of length 2: [kernel_height, kernel_width]
+
+  Returns:
+    a tensor with the kernel size.
+  """
+  shape = input_tensor.get_shape().as_list()
+  if shape[1] is None or shape[2] is None:
+    kernel_size_out = kernel_size
+  else:
+    kernel_size_out = [min(shape[1], kernel_size[0]),
+                       min(shape[2], kernel_size[1])]
+  return kernel_size_out
+
+
+def mobilenet_v1_arg_scope(is_training=True,
+                           weight_decay=0.00004,
+                           stddev=0.09,
+                           regularize_depthwise=False):
+  """Defines the default MobilenetV1 arg scope.
+
+  Args:
+    is_training: Whether or not we're training the model.
+    weight_decay: The weight decay to use for regularizing the model.
+    stddev: The standard deviation of the trunctated normal weight initializer.
+    regularize_depthwise: Whether or not apply regularization on depthwise.
+
+  Returns:
+    An `arg_scope` to use for the mobilenet v1 model.
+  """
+  batch_norm_params = {
+      'is_training': is_training,
+      'center': True,
+      'scale': True,
+      'decay': 0.9997,
+      'epsilon': 0.001,
+  }
+
+  # Set weight_decay for weights in Conv and DepthSepConv layers.
+  weights_init = tf.truncated_normal_initializer(stddev=stddev)
+  regularizer = tf.contrib.layers.l2_regularizer(weight_decay)
+  if regularize_depthwise:
+    depthwise_regularizer = regularizer
+  else:
+    depthwise_regularizer = None
+  with slim.arg_scope([slim.conv2d, slim.separable_conv2d],
+                      weights_initializer=weights_init,
+                      activation_fn=tf.nn.relu6, normalizer_fn=slim.batch_norm):
+    with slim.arg_scope([slim.batch_norm], **batch_norm_params):
+      with slim.arg_scope([slim.conv2d], weights_regularizer=regularizer):
+        with slim.arg_scope([slim.separable_conv2d],
+                            weights_regularizer=depthwise_regularizer) as sc:
+          return sc
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/mobilenet_v1_test.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/mobilenet_v1_test.py
new file mode 100755
index 0000000..44e6644
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/mobilenet_v1_test.py
@@ -0,0 +1,450 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# =============================================================================
+"""Tests for MobileNet v1."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import numpy as np
+import tensorflow as tf
+
+from nets import mobilenet_v1
+
+slim = tf.contrib.slim
+
+
+class MobilenetV1Test(tf.test.TestCase):
+
+  def testBuildClassificationNetwork(self):
+    batch_size = 5
+    height, width = 224, 224
+    num_classes = 1000
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    logits, end_points = mobilenet_v1.mobilenet_v1(inputs, num_classes)
+    self.assertTrue(logits.op.name.startswith('MobilenetV1/Logits'))
+    self.assertListEqual(logits.get_shape().as_list(),
+                         [batch_size, num_classes])
+    self.assertTrue('Predictions' in end_points)
+    self.assertListEqual(end_points['Predictions'].get_shape().as_list(),
+                         [batch_size, num_classes])
+
+  def testBuildBaseNetwork(self):
+    batch_size = 5
+    height, width = 224, 224
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    net, end_points = mobilenet_v1.mobilenet_v1_base(inputs)
+    self.assertTrue(net.op.name.startswith('MobilenetV1/Conv2d_13'))
+    self.assertListEqual(net.get_shape().as_list(),
+                         [batch_size, 7, 7, 1024])
+    expected_endpoints = ['Conv2d_0',
+                          'Conv2d_1_depthwise', 'Conv2d_1_pointwise',
+                          'Conv2d_2_depthwise', 'Conv2d_2_pointwise',
+                          'Conv2d_3_depthwise', 'Conv2d_3_pointwise',
+                          'Conv2d_4_depthwise', 'Conv2d_4_pointwise',
+                          'Conv2d_5_depthwise', 'Conv2d_5_pointwise',
+                          'Conv2d_6_depthwise', 'Conv2d_6_pointwise',
+                          'Conv2d_7_depthwise', 'Conv2d_7_pointwise',
+                          'Conv2d_8_depthwise', 'Conv2d_8_pointwise',
+                          'Conv2d_9_depthwise', 'Conv2d_9_pointwise',
+                          'Conv2d_10_depthwise', 'Conv2d_10_pointwise',
+                          'Conv2d_11_depthwise', 'Conv2d_11_pointwise',
+                          'Conv2d_12_depthwise', 'Conv2d_12_pointwise',
+                          'Conv2d_13_depthwise', 'Conv2d_13_pointwise']
+    self.assertItemsEqual(end_points.keys(), expected_endpoints)
+
+  def testBuildOnlyUptoFinalEndpoint(self):
+    batch_size = 5
+    height, width = 224, 224
+    endpoints = ['Conv2d_0',
+                 'Conv2d_1_depthwise', 'Conv2d_1_pointwise',
+                 'Conv2d_2_depthwise', 'Conv2d_2_pointwise',
+                 'Conv2d_3_depthwise', 'Conv2d_3_pointwise',
+                 'Conv2d_4_depthwise', 'Conv2d_4_pointwise',
+                 'Conv2d_5_depthwise', 'Conv2d_5_pointwise',
+                 'Conv2d_6_depthwise', 'Conv2d_6_pointwise',
+                 'Conv2d_7_depthwise', 'Conv2d_7_pointwise',
+                 'Conv2d_8_depthwise', 'Conv2d_8_pointwise',
+                 'Conv2d_9_depthwise', 'Conv2d_9_pointwise',
+                 'Conv2d_10_depthwise', 'Conv2d_10_pointwise',
+                 'Conv2d_11_depthwise', 'Conv2d_11_pointwise',
+                 'Conv2d_12_depthwise', 'Conv2d_12_pointwise',
+                 'Conv2d_13_depthwise', 'Conv2d_13_pointwise']
+    for index, endpoint in enumerate(endpoints):
+      with tf.Graph().as_default():
+        inputs = tf.random_uniform((batch_size, height, width, 3))
+        out_tensor, end_points = mobilenet_v1.mobilenet_v1_base(
+            inputs, final_endpoint=endpoint)
+        self.assertTrue(out_tensor.op.name.startswith(
+            'MobilenetV1/' + endpoint))
+        self.assertItemsEqual(endpoints[:index+1], end_points)
+
+  def testBuildCustomNetworkUsingConvDefs(self):
+    batch_size = 5
+    height, width = 224, 224
+    conv_defs = [
+        mobilenet_v1.Conv(kernel=[3, 3], stride=2, depth=32),
+        mobilenet_v1.DepthSepConv(kernel=[3, 3], stride=1, depth=64),
+        mobilenet_v1.DepthSepConv(kernel=[3, 3], stride=2, depth=128),
+        mobilenet_v1.DepthSepConv(kernel=[3, 3], stride=1, depth=512)
+    ]
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    net, end_points = mobilenet_v1.mobilenet_v1_base(
+        inputs, final_endpoint='Conv2d_3_pointwise', conv_defs=conv_defs)
+    self.assertTrue(net.op.name.startswith('MobilenetV1/Conv2d_3'))
+    self.assertListEqual(net.get_shape().as_list(),
+                         [batch_size, 56, 56, 512])
+    expected_endpoints = ['Conv2d_0',
+                          'Conv2d_1_depthwise', 'Conv2d_1_pointwise',
+                          'Conv2d_2_depthwise', 'Conv2d_2_pointwise',
+                          'Conv2d_3_depthwise', 'Conv2d_3_pointwise']
+    self.assertItemsEqual(end_points.keys(), expected_endpoints)
+
+  def testBuildAndCheckAllEndPointsUptoConv2d_13(self):
+    batch_size = 5
+    height, width = 224, 224
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    with slim.arg_scope([slim.conv2d, slim.separable_conv2d],
+                        normalizer_fn=slim.batch_norm):
+      _, end_points = mobilenet_v1.mobilenet_v1_base(
+          inputs, final_endpoint='Conv2d_13_pointwise')
+    endpoints_shapes = {'Conv2d_0': [batch_size, 112, 112, 32],
+                        'Conv2d_1_depthwise': [batch_size, 112, 112, 32],
+                        'Conv2d_1_pointwise': [batch_size, 112, 112, 64],
+                        'Conv2d_2_depthwise': [batch_size, 56, 56, 64],
+                        'Conv2d_2_pointwise': [batch_size, 56, 56, 128],
+                        'Conv2d_3_depthwise': [batch_size, 56, 56, 128],
+                        'Conv2d_3_pointwise': [batch_size, 56, 56, 128],
+                        'Conv2d_4_depthwise': [batch_size, 28, 28, 128],
+                        'Conv2d_4_pointwise': [batch_size, 28, 28, 256],
+                        'Conv2d_5_depthwise': [batch_size, 28, 28, 256],
+                        'Conv2d_5_pointwise': [batch_size, 28, 28, 256],
+                        'Conv2d_6_depthwise': [batch_size, 14, 14, 256],
+                        'Conv2d_6_pointwise': [batch_size, 14, 14, 512],
+                        'Conv2d_7_depthwise': [batch_size, 14, 14, 512],
+                        'Conv2d_7_pointwise': [batch_size, 14, 14, 512],
+                        'Conv2d_8_depthwise': [batch_size, 14, 14, 512],
+                        'Conv2d_8_pointwise': [batch_size, 14, 14, 512],
+                        'Conv2d_9_depthwise': [batch_size, 14, 14, 512],
+                        'Conv2d_9_pointwise': [batch_size, 14, 14, 512],
+                        'Conv2d_10_depthwise': [batch_size, 14, 14, 512],
+                        'Conv2d_10_pointwise': [batch_size, 14, 14, 512],
+                        'Conv2d_11_depthwise': [batch_size, 14, 14, 512],
+                        'Conv2d_11_pointwise': [batch_size, 14, 14, 512],
+                        'Conv2d_12_depthwise': [batch_size, 7, 7, 512],
+                        'Conv2d_12_pointwise': [batch_size, 7, 7, 1024],
+                        'Conv2d_13_depthwise': [batch_size, 7, 7, 1024],
+                        'Conv2d_13_pointwise': [batch_size, 7, 7, 1024]}
+    self.assertItemsEqual(endpoints_shapes.keys(), end_points.keys())
+    for endpoint_name, expected_shape in endpoints_shapes.iteritems():
+      self.assertTrue(endpoint_name in end_points)
+      self.assertListEqual(end_points[endpoint_name].get_shape().as_list(),
+                           expected_shape)
+
+  def testOutputStride16BuildAndCheckAllEndPointsUptoConv2d_13(self):
+    batch_size = 5
+    height, width = 224, 224
+    output_stride = 16
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    with slim.arg_scope([slim.conv2d, slim.separable_conv2d],
+                        normalizer_fn=slim.batch_norm):
+      _, end_points = mobilenet_v1.mobilenet_v1_base(
+          inputs, output_stride=output_stride,
+          final_endpoint='Conv2d_13_pointwise')
+    endpoints_shapes = {'Conv2d_0': [batch_size, 112, 112, 32],
+                        'Conv2d_1_depthwise': [batch_size, 112, 112, 32],
+                        'Conv2d_1_pointwise': [batch_size, 112, 112, 64],
+                        'Conv2d_2_depthwise': [batch_size, 56, 56, 64],
+                        'Conv2d_2_pointwise': [batch_size, 56, 56, 128],
+                        'Conv2d_3_depthwise': [batch_size, 56, 56, 128],
+                        'Conv2d_3_pointwise': [batch_size, 56, 56, 128],
+                        'Conv2d_4_depthwise': [batch_size, 28, 28, 128],
+                        'Conv2d_4_pointwise': [batch_size, 28, 28, 256],
+                        'Conv2d_5_depthwise': [batch_size, 28, 28, 256],
+                        'Conv2d_5_pointwise': [batch_size, 28, 28, 256],
+                        'Conv2d_6_depthwise': [batch_size, 14, 14, 256],
+                        'Conv2d_6_pointwise': [batch_size, 14, 14, 512],
+                        'Conv2d_7_depthwise': [batch_size, 14, 14, 512],
+                        'Conv2d_7_pointwise': [batch_size, 14, 14, 512],
+                        'Conv2d_8_depthwise': [batch_size, 14, 14, 512],
+                        'Conv2d_8_pointwise': [batch_size, 14, 14, 512],
+                        'Conv2d_9_depthwise': [batch_size, 14, 14, 512],
+                        'Conv2d_9_pointwise': [batch_size, 14, 14, 512],
+                        'Conv2d_10_depthwise': [batch_size, 14, 14, 512],
+                        'Conv2d_10_pointwise': [batch_size, 14, 14, 512],
+                        'Conv2d_11_depthwise': [batch_size, 14, 14, 512],
+                        'Conv2d_11_pointwise': [batch_size, 14, 14, 512],
+                        'Conv2d_12_depthwise': [batch_size, 14, 14, 512],
+                        'Conv2d_12_pointwise': [batch_size, 14, 14, 1024],
+                        'Conv2d_13_depthwise': [batch_size, 14, 14, 1024],
+                        'Conv2d_13_pointwise': [batch_size, 14, 14, 1024]}
+    self.assertItemsEqual(endpoints_shapes.keys(), end_points.keys())
+    for endpoint_name, expected_shape in endpoints_shapes.iteritems():
+      self.assertTrue(endpoint_name in end_points)
+      self.assertListEqual(end_points[endpoint_name].get_shape().as_list(),
+                           expected_shape)
+
+  def testOutputStride8BuildAndCheckAllEndPointsUptoConv2d_13(self):
+    batch_size = 5
+    height, width = 224, 224
+    output_stride = 8
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    with slim.arg_scope([slim.conv2d, slim.separable_conv2d],
+                        normalizer_fn=slim.batch_norm):
+      _, end_points = mobilenet_v1.mobilenet_v1_base(
+          inputs, output_stride=output_stride,
+          final_endpoint='Conv2d_13_pointwise')
+    endpoints_shapes = {'Conv2d_0': [batch_size, 112, 112, 32],
+                        'Conv2d_1_depthwise': [batch_size, 112, 112, 32],
+                        'Conv2d_1_pointwise': [batch_size, 112, 112, 64],
+                        'Conv2d_2_depthwise': [batch_size, 56, 56, 64],
+                        'Conv2d_2_pointwise': [batch_size, 56, 56, 128],
+                        'Conv2d_3_depthwise': [batch_size, 56, 56, 128],
+                        'Conv2d_3_pointwise': [batch_size, 56, 56, 128],
+                        'Conv2d_4_depthwise': [batch_size, 28, 28, 128],
+                        'Conv2d_4_pointwise': [batch_size, 28, 28, 256],
+                        'Conv2d_5_depthwise': [batch_size, 28, 28, 256],
+                        'Conv2d_5_pointwise': [batch_size, 28, 28, 256],
+                        'Conv2d_6_depthwise': [batch_size, 28, 28, 256],
+                        'Conv2d_6_pointwise': [batch_size, 28, 28, 512],
+                        'Conv2d_7_depthwise': [batch_size, 28, 28, 512],
+                        'Conv2d_7_pointwise': [batch_size, 28, 28, 512],
+                        'Conv2d_8_depthwise': [batch_size, 28, 28, 512],
+                        'Conv2d_8_pointwise': [batch_size, 28, 28, 512],
+                        'Conv2d_9_depthwise': [batch_size, 28, 28, 512],
+                        'Conv2d_9_pointwise': [batch_size, 28, 28, 512],
+                        'Conv2d_10_depthwise': [batch_size, 28, 28, 512],
+                        'Conv2d_10_pointwise': [batch_size, 28, 28, 512],
+                        'Conv2d_11_depthwise': [batch_size, 28, 28, 512],
+                        'Conv2d_11_pointwise': [batch_size, 28, 28, 512],
+                        'Conv2d_12_depthwise': [batch_size, 28, 28, 512],
+                        'Conv2d_12_pointwise': [batch_size, 28, 28, 1024],
+                        'Conv2d_13_depthwise': [batch_size, 28, 28, 1024],
+                        'Conv2d_13_pointwise': [batch_size, 28, 28, 1024]}
+    self.assertItemsEqual(endpoints_shapes.keys(), end_points.keys())
+    for endpoint_name, expected_shape in endpoints_shapes.iteritems():
+      self.assertTrue(endpoint_name in end_points)
+      self.assertListEqual(end_points[endpoint_name].get_shape().as_list(),
+                           expected_shape)
+
+  def testBuildAndCheckAllEndPointsApproximateFaceNet(self):
+    batch_size = 5
+    height, width = 128, 128
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    with slim.arg_scope([slim.conv2d, slim.separable_conv2d],
+                        normalizer_fn=slim.batch_norm):
+      _, end_points = mobilenet_v1.mobilenet_v1_base(
+          inputs, final_endpoint='Conv2d_13_pointwise', depth_multiplier=0.75)
+    # For the Conv2d_0 layer FaceNet has depth=16
+    endpoints_shapes = {'Conv2d_0': [batch_size, 64, 64, 24],
+                        'Conv2d_1_depthwise': [batch_size, 64, 64, 24],
+                        'Conv2d_1_pointwise': [batch_size, 64, 64, 48],
+                        'Conv2d_2_depthwise': [batch_size, 32, 32, 48],
+                        'Conv2d_2_pointwise': [batch_size, 32, 32, 96],
+                        'Conv2d_3_depthwise': [batch_size, 32, 32, 96],
+                        'Conv2d_3_pointwise': [batch_size, 32, 32, 96],
+                        'Conv2d_4_depthwise': [batch_size, 16, 16, 96],
+                        'Conv2d_4_pointwise': [batch_size, 16, 16, 192],
+                        'Conv2d_5_depthwise': [batch_size, 16, 16, 192],
+                        'Conv2d_5_pointwise': [batch_size, 16, 16, 192],
+                        'Conv2d_6_depthwise': [batch_size, 8, 8, 192],
+                        'Conv2d_6_pointwise': [batch_size, 8, 8, 384],
+                        'Conv2d_7_depthwise': [batch_size, 8, 8, 384],
+                        'Conv2d_7_pointwise': [batch_size, 8, 8, 384],
+                        'Conv2d_8_depthwise': [batch_size, 8, 8, 384],
+                        'Conv2d_8_pointwise': [batch_size, 8, 8, 384],
+                        'Conv2d_9_depthwise': [batch_size, 8, 8, 384],
+                        'Conv2d_9_pointwise': [batch_size, 8, 8, 384],
+                        'Conv2d_10_depthwise': [batch_size, 8, 8, 384],
+                        'Conv2d_10_pointwise': [batch_size, 8, 8, 384],
+                        'Conv2d_11_depthwise': [batch_size, 8, 8, 384],
+                        'Conv2d_11_pointwise': [batch_size, 8, 8, 384],
+                        'Conv2d_12_depthwise': [batch_size, 4, 4, 384],
+                        'Conv2d_12_pointwise': [batch_size, 4, 4, 768],
+                        'Conv2d_13_depthwise': [batch_size, 4, 4, 768],
+                        'Conv2d_13_pointwise': [batch_size, 4, 4, 768]}
+    self.assertItemsEqual(endpoints_shapes.keys(), end_points.keys())
+    for endpoint_name, expected_shape in endpoints_shapes.iteritems():
+      self.assertTrue(endpoint_name in end_points)
+      self.assertListEqual(end_points[endpoint_name].get_shape().as_list(),
+                           expected_shape)
+
+  def testModelHasExpectedNumberOfParameters(self):
+    batch_size = 5
+    height, width = 224, 224
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    with slim.arg_scope([slim.conv2d, slim.separable_conv2d],
+                        normalizer_fn=slim.batch_norm):
+      mobilenet_v1.mobilenet_v1_base(inputs)
+      total_params, _ = slim.model_analyzer.analyze_vars(
+          slim.get_model_variables())
+      self.assertAlmostEqual(3217920L, total_params)
+
+  def testBuildEndPointsWithDepthMultiplierLessThanOne(self):
+    batch_size = 5
+    height, width = 224, 224
+    num_classes = 1000
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    _, end_points = mobilenet_v1.mobilenet_v1(inputs, num_classes)
+
+    endpoint_keys = [key for key in end_points.keys() if key.startswith('Conv')]
+
+    _, end_points_with_multiplier = mobilenet_v1.mobilenet_v1(
+        inputs, num_classes, scope='depth_multiplied_net',
+        depth_multiplier=0.5)
+
+    for key in endpoint_keys:
+      original_depth = end_points[key].get_shape().as_list()[3]
+      new_depth = end_points_with_multiplier[key].get_shape().as_list()[3]
+      self.assertEqual(0.5 * original_depth, new_depth)
+
+  def testBuildEndPointsWithDepthMultiplierGreaterThanOne(self):
+    batch_size = 5
+    height, width = 224, 224
+    num_classes = 1000
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    _, end_points = mobilenet_v1.mobilenet_v1(inputs, num_classes)
+
+    endpoint_keys = [key for key in end_points.keys()
+                     if key.startswith('Mixed') or key.startswith('Conv')]
+
+    _, end_points_with_multiplier = mobilenet_v1.mobilenet_v1(
+        inputs, num_classes, scope='depth_multiplied_net',
+        depth_multiplier=2.0)
+
+    for key in endpoint_keys:
+      original_depth = end_points[key].get_shape().as_list()[3]
+      new_depth = end_points_with_multiplier[key].get_shape().as_list()[3]
+      self.assertEqual(2.0 * original_depth, new_depth)
+
+  def testRaiseValueErrorWithInvalidDepthMultiplier(self):
+    batch_size = 5
+    height, width = 224, 224
+    num_classes = 1000
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    with self.assertRaises(ValueError):
+      _ = mobilenet_v1.mobilenet_v1(
+          inputs, num_classes, depth_multiplier=-0.1)
+    with self.assertRaises(ValueError):
+      _ = mobilenet_v1.mobilenet_v1(
+          inputs, num_classes, depth_multiplier=0.0)
+
+  def testHalfSizeImages(self):
+    batch_size = 5
+    height, width = 112, 112
+    num_classes = 1000
+
+    inputs = tf.random_uniform((batch_size, height, width, 3))
+    logits, end_points = mobilenet_v1.mobilenet_v1(inputs, num_classes)
+    self.assertTrue(logits.op.name.startswith('MobilenetV1/Logits'))
+    self.assertListEqual(logits.get_shape().as_list(),
+                         [batch_size, num_classes])
+    pre_pool = end_points['Conv2d_13_pointwise']
+    self.assertListEqual(pre_pool.get_shape().as_list(),
+                         [batch_size, 4, 4, 1024])
+
+  def testUnknownImageShape(self):
+    tf.reset_default_graph()
+    batch_size = 2
+    height, width = 224, 224
+    num_classes = 1000
+    input_np = np.random.uniform(0, 1, (batch_size, height, width, 3))
+    with self.test_session() as sess:
+      inputs = tf.placeholder(tf.float32, shape=(batch_size, None, None, 3))
+      logits, end_points = mobilenet_v1.mobilenet_v1(inputs, num_classes)
+      self.assertTrue(logits.op.name.startswith('MobilenetV1/Logits'))
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [batch_size, num_classes])
+      pre_pool = end_points['Conv2d_13_pointwise']
+      feed_dict = {inputs: input_np}
+      tf.global_variables_initializer().run()
+      pre_pool_out = sess.run(pre_pool, feed_dict=feed_dict)
+      self.assertListEqual(list(pre_pool_out.shape), [batch_size, 7, 7, 1024])
+
+  def testUnknowBatchSize(self):
+    batch_size = 1
+    height, width = 224, 224
+    num_classes = 1000
+
+    inputs = tf.placeholder(tf.float32, (None, height, width, 3))
+    logits, _ = mobilenet_v1.mobilenet_v1(inputs, num_classes)
+    self.assertTrue(logits.op.name.startswith('MobilenetV1/Logits'))
+    self.assertListEqual(logits.get_shape().as_list(),
+                         [None, num_classes])
+    images = tf.random_uniform((batch_size, height, width, 3))
+
+    with self.test_session() as sess:
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(logits, {inputs: images.eval()})
+      self.assertEquals(output.shape, (batch_size, num_classes))
+
+  def testEvaluation(self):
+    batch_size = 2
+    height, width = 224, 224
+    num_classes = 1000
+
+    eval_inputs = tf.random_uniform((batch_size, height, width, 3))
+    logits, _ = mobilenet_v1.mobilenet_v1(eval_inputs, num_classes,
+                                          is_training=False)
+    predictions = tf.argmax(logits, 1)
+
+    with self.test_session() as sess:
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(predictions)
+      self.assertEquals(output.shape, (batch_size,))
+
+  def testTrainEvalWithReuse(self):
+    train_batch_size = 5
+    eval_batch_size = 2
+    height, width = 150, 150
+    num_classes = 1000
+
+    train_inputs = tf.random_uniform((train_batch_size, height, width, 3))
+    mobilenet_v1.mobilenet_v1(train_inputs, num_classes)
+    eval_inputs = tf.random_uniform((eval_batch_size, height, width, 3))
+    logits, _ = mobilenet_v1.mobilenet_v1(eval_inputs, num_classes,
+                                          reuse=True)
+    predictions = tf.argmax(logits, 1)
+
+    with self.test_session() as sess:
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(predictions)
+      self.assertEquals(output.shape, (eval_batch_size,))
+
+  def testLogitsNotSqueezed(self):
+    num_classes = 25
+    images = tf.random_uniform([1, 224, 224, 3])
+    logits, _ = mobilenet_v1.mobilenet_v1(images,
+                                          num_classes=num_classes,
+                                          spatial_squeeze=False)
+
+    with self.test_session() as sess:
+      tf.global_variables_initializer().run()
+      logits_out = sess.run(logits)
+      self.assertListEqual(list(logits_out.shape), [1, 1, 1, num_classes])
+
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/nets_factory.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/nets_factory.py
new file mode 100755
index 0000000..7c04161
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/nets_factory.py
@@ -0,0 +1,112 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Contains a factory for building various models."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+import functools
+
+import tensorflow as tf
+
+from nets import alexnet
+from nets import cifarnet
+from nets import inception
+from nets import lenet
+from nets import mobilenet_v1
+from nets import overfeat
+from nets import resnet_v1
+from nets import resnet_v2
+from nets import vgg
+
+slim = tf.contrib.slim
+
+networks_map = {'alexnet_v2': alexnet.alexnet_v2,
+                'cifarnet': cifarnet.cifarnet,
+                'overfeat': overfeat.overfeat,
+                'vgg_a': vgg.vgg_a,
+                'vgg_16': vgg.vgg_16,
+                'vgg_19': vgg.vgg_19,
+                'inception_v1': inception.inception_v1,
+                'inception_v2': inception.inception_v2,
+                'inception_v3': inception.inception_v3,
+                'inception_v4': inception.inception_v4,
+                'inception_resnet_v2': inception.inception_resnet_v2,
+                'lenet': lenet.lenet,
+                'resnet_v1_50': resnet_v1.resnet_v1_50,
+                'resnet_v1_101': resnet_v1.resnet_v1_101,
+                'resnet_v1_152': resnet_v1.resnet_v1_152,
+                'resnet_v1_200': resnet_v1.resnet_v1_200,
+                'resnet_v2_50': resnet_v2.resnet_v2_50,
+                'resnet_v2_101': resnet_v2.resnet_v2_101,
+                'resnet_v2_152': resnet_v2.resnet_v2_152,
+                'resnet_v2_200': resnet_v2.resnet_v2_200,
+                'mobilenet_v1': mobilenet_v1.mobilenet_v1,
+               }
+
+arg_scopes_map = {'alexnet_v2': alexnet.alexnet_v2_arg_scope,
+                  'cifarnet': cifarnet.cifarnet_arg_scope,
+                  'overfeat': overfeat.overfeat_arg_scope,
+                  'vgg_a': vgg.vgg_arg_scope,
+                  'vgg_16': vgg.vgg_arg_scope,
+                  'vgg_19': vgg.vgg_arg_scope,
+                  'inception_v1': inception.inception_v3_arg_scope,
+                  'inception_v2': inception.inception_v3_arg_scope,
+                  'inception_v3': inception.inception_v3_arg_scope,
+                  'inception_v4': inception.inception_v4_arg_scope,
+                  'inception_resnet_v2':
+                  inception.inception_resnet_v2_arg_scope,
+                  'lenet': lenet.lenet_arg_scope,
+                  'resnet_v1_50': resnet_v1.resnet_arg_scope,
+                  'resnet_v1_101': resnet_v1.resnet_arg_scope,
+                  'resnet_v1_152': resnet_v1.resnet_arg_scope,
+                  'resnet_v1_200': resnet_v1.resnet_arg_scope,
+                  'resnet_v2_50': resnet_v2.resnet_arg_scope,
+                  'resnet_v2_101': resnet_v2.resnet_arg_scope,
+                  'resnet_v2_152': resnet_v2.resnet_arg_scope,
+                  'resnet_v2_200': resnet_v2.resnet_arg_scope,
+                  'mobilenet_v1': mobilenet_v1.mobilenet_v1_arg_scope,
+                 }
+
+
+def get_network_fn(name, num_classes, weight_decay=0.0, is_training=False):
+  """Returns a network_fn such as `logits, end_points = network_fn(images)`.
+
+  Args:
+    name: The name of the network.
+    num_classes: The number of classes to use for classification.
+    weight_decay: The l2 coefficient for the model weights.
+    is_training: `True` if the model is being used for training and `False`
+      otherwise.
+
+  Returns:
+    network_fn: A function that applies the model to a batch of images. It has
+      the following signature:
+        logits, end_points = network_fn(images)
+  Raises:
+    ValueError: If network `name` is not recognized.
+  """
+  if name not in networks_map:
+    raise ValueError('Name of network unknown %s' % name)
+  arg_scope = arg_scopes_map[name](weight_decay=weight_decay)
+  func = networks_map[name]
+  @functools.wraps(func)
+  def network_fn(images):
+    with slim.arg_scope(arg_scope):
+      return func(images, num_classes, is_training=is_training)
+  if hasattr(func, 'default_image_size'):
+    network_fn.default_image_size = func.default_image_size
+
+  return network_fn
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/nets_factory_test.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/nets_factory_test.py
new file mode 100755
index 0000000..b4ab1f8
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/nets_factory_test.py
@@ -0,0 +1,61 @@
+# Copyright 2016 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for slim.inception."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf
+
+from nets import nets_factory
+
+slim = tf.contrib.slim
+
+
+class NetworksTest(tf.test.TestCase):
+
+  def testGetNetworkFn(self):
+    batch_size = 5
+    num_classes = 1000
+    for net in nets_factory.networks_map:
+      with self.test_session():
+        net_fn = nets_factory.get_network_fn(net, num_classes)
+        # Most networks use 224 as their default_image_size
+        image_size = getattr(net_fn, 'default_image_size', 224)
+        inputs = tf.random_uniform((batch_size, image_size, image_size, 3))
+        logits, end_points = net_fn(inputs)
+        self.assertTrue(isinstance(logits, tf.Tensor))
+        self.assertTrue(isinstance(end_points, dict))
+        self.assertEqual(logits.get_shape().as_list()[0], batch_size)
+        self.assertEqual(logits.get_shape().as_list()[-1], num_classes)
+
+  def testGetNetworkFnArgScope(self):
+    batch_size = 5
+    num_classes = 10
+    net = 'cifarnet'
+    with self.test_session(use_gpu=True):
+      net_fn = nets_factory.get_network_fn(net, num_classes)
+      image_size = getattr(net_fn, 'default_image_size', 224)
+      with slim.arg_scope([slim.model_variable, slim.variable],
+                          device='/CPU:0'):
+        inputs = tf.random_uniform((batch_size, image_size, image_size, 3))
+        net_fn(inputs)
+      weights = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, 'CifarNet/conv1')[0]
+      self.assertDeviceEqual('/CPU:0', weights.device)
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/overfeat.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/overfeat.py
new file mode 100755
index 0000000..64a5425
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/overfeat.py
@@ -0,0 +1,118 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Contains the model definition for the OverFeat network.
+
+The definition for the network was obtained from:
+  OverFeat: Integrated Recognition, Localization and Detection using
+  Convolutional Networks
+  Pierre Sermanet, David Eigen, Xiang Zhang, Michael Mathieu, Rob Fergus and
+  Yann LeCun, 2014
+  http://arxiv.org/abs/1312.6229
+
+Usage:
+  with slim.arg_scope(overfeat.overfeat_arg_scope()):
+    outputs, end_points = overfeat.overfeat(inputs)
+
+@@overfeat
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf
+
+slim = tf.contrib.slim
+trunc_normal = lambda stddev: tf.truncated_normal_initializer(0.0, stddev)
+
+
+def overfeat_arg_scope(weight_decay=0.0005):
+  with slim.arg_scope([slim.conv2d, slim.fully_connected],
+                      activation_fn=tf.nn.relu,
+                      weights_regularizer=slim.l2_regularizer(weight_decay),
+                      biases_initializer=tf.zeros_initializer()):
+    with slim.arg_scope([slim.conv2d], padding='SAME'):
+      with slim.arg_scope([slim.max_pool2d], padding='VALID') as arg_sc:
+        return arg_sc
+
+
+def overfeat(inputs,
+             num_classes=1000,
+             is_training=True,
+             dropout_keep_prob=0.5,
+             spatial_squeeze=True,
+             scope='overfeat'):
+  """Contains the model definition for the OverFeat network.
+
+  The definition for the network was obtained from:
+    OverFeat: Integrated Recognition, Localization and Detection using
+    Convolutional Networks
+    Pierre Sermanet, David Eigen, Xiang Zhang, Michael Mathieu, Rob Fergus and
+    Yann LeCun, 2014
+    http://arxiv.org/abs/1312.6229
+
+  Note: All the fully_connected layers have been transformed to conv2d layers.
+        To use in classification mode, resize input to 231x231. To use in fully
+        convolutional mode, set spatial_squeeze to false.
+
+  Args:
+    inputs: a tensor of size [batch_size, height, width, channels].
+    num_classes: number of predicted classes.
+    is_training: whether or not the model is being trained.
+    dropout_keep_prob: the probability that activations are kept in the dropout
+      layers during training.
+    spatial_squeeze: whether or not should squeeze the spatial dimensions of the
+      outputs. Useful to remove unnecessary dimensions for classification.
+    scope: Optional scope for the variables.
+
+  Returns:
+    the last op containing the log predictions and end_points dict.
+
+  """
+  with tf.variable_scope(scope, 'overfeat', [inputs]) as sc:
+    end_points_collection = sc.name + '_end_points'
+    # Collect outputs for conv2d, fully_connected and max_pool2d
+    with slim.arg_scope([slim.conv2d, slim.fully_connected, slim.max_pool2d],
+                        outputs_collections=end_points_collection):
+      net = slim.conv2d(inputs, 64, [11, 11], 4, padding='VALID',
+                        scope='conv1')
+      net = slim.max_pool2d(net, [2, 2], scope='pool1')
+      net = slim.conv2d(net, 256, [5, 5], padding='VALID', scope='conv2')
+      net = slim.max_pool2d(net, [2, 2], scope='pool2')
+      net = slim.conv2d(net, 512, [3, 3], scope='conv3')
+      net = slim.conv2d(net, 1024, [3, 3], scope='conv4')
+      net = slim.conv2d(net, 1024, [3, 3], scope='conv5')
+      net = slim.max_pool2d(net, [2, 2], scope='pool5')
+      with slim.arg_scope([slim.conv2d],
+                          weights_initializer=trunc_normal(0.005),
+                          biases_initializer=tf.constant_initializer(0.1)):
+        # Use conv2d instead of fully_connected layers.
+        net = slim.conv2d(net, 3072, [6, 6], padding='VALID', scope='fc6')
+        net = slim.dropout(net, dropout_keep_prob, is_training=is_training,
+                           scope='dropout6')
+        net = slim.conv2d(net, 4096, [1, 1], scope='fc7')
+        net = slim.dropout(net, dropout_keep_prob, is_training=is_training,
+                           scope='dropout7')
+        net = slim.conv2d(net, num_classes, [1, 1],
+                          activation_fn=None,
+                          normalizer_fn=None,
+                          biases_initializer=tf.zeros_initializer(),
+                          scope='fc8')
+      # Convert end_points_collection into a end_point dict.
+      end_points = slim.utils.convert_collection_to_dict(end_points_collection)
+      if spatial_squeeze:
+        net = tf.squeeze(net, [1, 2], name='fc8/squeezed')
+        end_points[sc.name + '/fc8'] = net
+      return net, end_points
+overfeat.default_image_size = 231
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/overfeat_test.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/overfeat_test.py
new file mode 100755
index 0000000..446f9ac
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/overfeat_test.py
@@ -0,0 +1,145 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for slim.slim_nets.overfeat."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf
+
+from nets import overfeat
+
+slim = tf.contrib.slim
+
+
+class OverFeatTest(tf.test.TestCase):
+
+  def testBuild(self):
+    batch_size = 5
+    height, width = 231, 231
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, _ = overfeat.overfeat(inputs, num_classes)
+      self.assertEquals(logits.op.name, 'overfeat/fc8/squeezed')
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [batch_size, num_classes])
+
+  def testFullyConvolutional(self):
+    batch_size = 1
+    height, width = 281, 281
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, _ = overfeat.overfeat(inputs, num_classes, spatial_squeeze=False)
+      self.assertEquals(logits.op.name, 'overfeat/fc8/BiasAdd')
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [batch_size, 2, 2, num_classes])
+
+  def testEndPoints(self):
+    batch_size = 5
+    height, width = 231, 231
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      _, end_points = overfeat.overfeat(inputs, num_classes)
+      expected_names = ['overfeat/conv1',
+                        'overfeat/pool1',
+                        'overfeat/conv2',
+                        'overfeat/pool2',
+                        'overfeat/conv3',
+                        'overfeat/conv4',
+                        'overfeat/conv5',
+                        'overfeat/pool5',
+                        'overfeat/fc6',
+                        'overfeat/fc7',
+                        'overfeat/fc8'
+                       ]
+      self.assertSetEqual(set(end_points.keys()), set(expected_names))
+
+  def testModelVariables(self):
+    batch_size = 5
+    height, width = 231, 231
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      overfeat.overfeat(inputs, num_classes)
+      expected_names = ['overfeat/conv1/weights',
+                        'overfeat/conv1/biases',
+                        'overfeat/conv2/weights',
+                        'overfeat/conv2/biases',
+                        'overfeat/conv3/weights',
+                        'overfeat/conv3/biases',
+                        'overfeat/conv4/weights',
+                        'overfeat/conv4/biases',
+                        'overfeat/conv5/weights',
+                        'overfeat/conv5/biases',
+                        'overfeat/fc6/weights',
+                        'overfeat/fc6/biases',
+                        'overfeat/fc7/weights',
+                        'overfeat/fc7/biases',
+                        'overfeat/fc8/weights',
+                        'overfeat/fc8/biases',
+                       ]
+      model_variables = [v.op.name for v in slim.get_model_variables()]
+      self.assertSetEqual(set(model_variables), set(expected_names))
+
+  def testEvaluation(self):
+    batch_size = 2
+    height, width = 231, 231
+    num_classes = 1000
+    with self.test_session():
+      eval_inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, _ = overfeat.overfeat(eval_inputs, is_training=False)
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [batch_size, num_classes])
+      predictions = tf.argmax(logits, 1)
+      self.assertListEqual(predictions.get_shape().as_list(), [batch_size])
+
+  def testTrainEvalWithReuse(self):
+    train_batch_size = 2
+    eval_batch_size = 1
+    train_height, train_width = 231, 231
+    eval_height, eval_width = 281, 281
+    num_classes = 1000
+    with self.test_session():
+      train_inputs = tf.random_uniform(
+          (train_batch_size, train_height, train_width, 3))
+      logits, _ = overfeat.overfeat(train_inputs)
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [train_batch_size, num_classes])
+      tf.get_variable_scope().reuse_variables()
+      eval_inputs = tf.random_uniform(
+          (eval_batch_size, eval_height, eval_width, 3))
+      logits, _ = overfeat.overfeat(eval_inputs, is_training=False,
+                                    spatial_squeeze=False)
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [eval_batch_size, 2, 2, num_classes])
+      logits = tf.reduce_mean(logits, [1, 2])
+      predictions = tf.argmax(logits, 1)
+      self.assertEquals(predictions.get_shape().as_list(), [eval_batch_size])
+
+  def testForward(self):
+    batch_size = 1
+    height, width = 231, 231
+    with self.test_session() as sess:
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, _ = overfeat.overfeat(inputs)
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(logits)
+      self.assertTrue(output.any())
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/resnet_utils.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/resnet_utils.py
new file mode 100755
index 0000000..bb674ea
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/resnet_utils.py
@@ -0,0 +1,244 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Contains building blocks for various versions of Residual Networks.
+
+Residual networks (ResNets) were proposed in:
+  Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
+  Deep Residual Learning for Image Recognition. arXiv:1512.03385, 2015
+
+More variants were introduced in:
+  Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
+  Identity Mappings in Deep Residual Networks. arXiv: 1603.05027, 2016
+
+We can obtain different ResNet variants by changing the network depth, width,
+and form of residual unit. This module implements the infrastructure for
+building them. Concrete ResNet units and full ResNet networks are implemented in
+the accompanying resnet_v1.py and resnet_v2.py modules.
+
+Compared to https://github.com/KaimingHe/deep-residual-networks, in the current
+implementation we subsample the output activations in the last residual unit of
+each block, instead of subsampling the input activations in the first residual
+unit of each block. The two implementations give identical results but our
+implementation is more memory efficient.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import collections
+import tensorflow as tf
+
+slim = tf.contrib.slim
+
+
+class Block(collections.namedtuple('Block', ['scope', 'unit_fn', 'args'])):
+  """A named tuple describing a ResNet block.
+
+  Its parts are:
+    scope: The scope of the `Block`.
+    unit_fn: The ResNet unit function which takes as input a `Tensor` and
+      returns another `Tensor` with the output of the ResNet unit.
+    args: A list of length equal to the number of units in the `Block`. The list
+      contains one (depth, depth_bottleneck, stride) tuple for each unit in the
+      block to serve as argument to unit_fn.
+  """
+
+
+def subsample(inputs, factor, scope=None):
+  """Subsamples the input along the spatial dimensions.
+
+  Args:
+    inputs: A `Tensor` of size [batch, height_in, width_in, channels].
+    factor: The subsampling factor.
+    scope: Optional variable_scope.
+
+  Returns:
+    output: A `Tensor` of size [batch, height_out, width_out, channels] with the
+      input, either intact (if factor == 1) or subsampled (if factor > 1).
+  """
+  if factor == 1:
+    return inputs
+  else:
+    return slim.max_pool2d(inputs, [1, 1], stride=factor, scope=scope)
+
+
+def conv2d_same(inputs, num_outputs, kernel_size, stride, rate=1, scope=None):
+  """Strided 2-D convolution with 'SAME' padding.
+
+  When stride > 1, then we do explicit zero-padding, followed by conv2d with
+  'VALID' padding.
+
+  Note that
+
+     net = conv2d_same(inputs, num_outputs, 3, stride=stride)
+
+  is equivalent to
+
+     net = slim.conv2d(inputs, num_outputs, 3, stride=1, padding='SAME')
+     net = subsample(net, factor=stride)
+
+  whereas
+
+     net = slim.conv2d(inputs, num_outputs, 3, stride=stride, padding='SAME')
+
+  is different when the input's height or width is even, which is why we add the
+  current function. For more details, see ResnetUtilsTest.testConv2DSameEven().
+
+  Args:
+    inputs: A 4-D tensor of size [batch, height_in, width_in, channels].
+    num_outputs: An integer, the number of output filters.
+    kernel_size: An int with the kernel_size of the filters.
+    stride: An integer, the output stride.
+    rate: An integer, rate for atrous convolution.
+    scope: Scope.
+
+  Returns:
+    output: A 4-D tensor of size [batch, height_out, width_out, channels] with
+      the convolution output.
+  """
+  if stride == 1:
+    return slim.conv2d(inputs, num_outputs, kernel_size, stride=1, rate=rate,
+                       padding='SAME', scope=scope)
+  else:
+    kernel_size_effective = kernel_size + (kernel_size - 1) * (rate - 1)
+    pad_total = kernel_size_effective - 1
+    pad_beg = pad_total // 2
+    pad_end = pad_total - pad_beg
+    inputs = tf.pad(inputs,
+                    [[0, 0], [pad_beg, pad_end], [pad_beg, pad_end], [0, 0]])
+    return slim.conv2d(inputs, num_outputs, kernel_size, stride=stride,
+                       rate=rate, padding='VALID', scope=scope)
+
+
+@slim.add_arg_scope
+def stack_blocks_dense(net, blocks, output_stride=None,
+                       outputs_collections=None):
+  """Stacks ResNet `Blocks` and controls output feature density.
+
+  First, this function creates scopes for the ResNet in the form of
+  'block_name/unit_1', 'block_name/unit_2', etc.
+
+  Second, this function allows the user to explicitly control the ResNet
+  output_stride, which is the ratio of the input to output spatial resolution.
+  This is useful for dense prediction tasks such as semantic segmentation or
+  object detection.
+
+  Most ResNets consist of 4 ResNet blocks and subsample the activations by a
+  factor of 2 when transitioning between consecutive ResNet blocks. This results
+  to a nominal ResNet output_stride equal to 8. If we set the output_stride to
+  half the nominal network stride (e.g., output_stride=4), then we compute
+  responses twice.
+
+  Control of the output feature density is implemented by atrous convolution.
+
+  Args:
+    net: A `Tensor` of size [batch, height, width, channels].
+    blocks: A list of length equal to the number of ResNet `Blocks`. Each
+      element is a ResNet `Block` object describing the units in the `Block`.
+    output_stride: If `None`, then the output will be computed at the nominal
+      network stride. If output_stride is not `None`, it specifies the requested
+      ratio of input to output spatial resolution, which needs to be equal to
+      the product of unit strides from the start up to some level of the ResNet.
+      For example, if the ResNet employs units with strides 1, 2, 1, 3, 4, 1,
+      then valid values for the output_stride are 1, 2, 6, 24 or None (which
+      is equivalent to output_stride=24).
+    outputs_collections: Collection to add the ResNet block outputs.
+
+  Returns:
+    net: Output tensor with stride equal to the specified output_stride.
+
+  Raises:
+    ValueError: If the target output_stride is not valid.
+  """
+  # The current_stride variable keeps track of the effective stride of the
+  # activations. This allows us to invoke atrous convolution whenever applying
+  # the next residual unit would result in the activations having stride larger
+  # than the target output_stride.
+  current_stride = 1
+
+  # The atrous convolution rate parameter.
+  rate = 1
+
+  for block in blocks:
+    with tf.variable_scope(block.scope, 'block', [net]) as sc:
+      for i, unit in enumerate(block.args):
+        if output_stride is not None and current_stride > output_stride:
+          raise ValueError('The target output_stride cannot be reached.')
+
+        with tf.variable_scope('unit_%d' % (i + 1), values=[net]):
+          # If we have reached the target output_stride, then we need to employ
+          # atrous convolution with stride=1 and multiply the atrous rate by the
+          # current unit's stride for use in subsequent layers.
+          if output_stride is not None and current_stride == output_stride:
+            net = block.unit_fn(net, rate=rate, **dict(unit, stride=1))
+            rate *= unit.get('stride', 1)
+
+          else:
+            net = block.unit_fn(net, rate=1, **unit)
+            current_stride *= unit.get('stride', 1)
+      net = slim.utils.collect_named_outputs(outputs_collections, sc.name, net)
+
+  if output_stride is not None and current_stride != output_stride:
+    raise ValueError('The target output_stride cannot be reached.')
+
+  return net
+
+
+def resnet_arg_scope(weight_decay=0.0001,
+                     batch_norm_decay=0.997, #0.997
+                     batch_norm_epsilon=1e-5,
+                     batch_norm_scale=True):
+  """Defines the default ResNet arg scope.
+
+  TODO(gpapan): The batch-normalization related default values above are
+    appropriate for use in conjunction with the reference ResNet models
+    released at https://github.com/KaimingHe/deep-residual-networks. When
+    training ResNets from scratch, they might need to be tuned.
+
+  Args:
+    weight_decay: The weight decay to use for regularizing the model.
+    batch_norm_decay: The moving average decay when estimating layer activation
+      statistics in batch normalization.
+    batch_norm_epsilon: Small constant to prevent division by zero when
+      normalizing activations by their variance in batch normalization.
+    batch_norm_scale: If True, uses an explicit `gamma` multiplier to scale the
+      activations in the batch normalization layer.
+
+  Returns:
+    An `arg_scope` to use for the resnet models.
+  """
+  batch_norm_params = {
+      'decay': batch_norm_decay,
+      'epsilon': batch_norm_epsilon,
+      'scale': batch_norm_scale,
+      'updates_collections': tf.GraphKeys.UPDATE_OPS,
+  }
+
+  with slim.arg_scope(
+      [slim.conv2d],
+      weights_regularizer=slim.l2_regularizer(weight_decay),
+      weights_initializer=slim.variance_scaling_initializer(),
+      activation_fn=tf.nn.relu,
+      normalizer_fn=slim.batch_norm,
+      normalizer_params=batch_norm_params):
+    with slim.arg_scope([slim.batch_norm], **batch_norm_params):
+      # The following implies padding='SAME' for pool1, which makes feature
+      # alignment easier for dense prediction tasks. This is also used in
+      # https://github.com/facebook/fb.resnet.torch. However the accompanying
+      # code of 'Deep Residual Learning for Image Recognition' uses
+      # padding='VALID' for pool1. You can switch to that choice by setting
+      # slim.arg_scope([slim.max_pool2d], padding='VALID').
+      with slim.arg_scope([slim.max_pool2d], padding='SAME') as arg_sc:
+        return arg_sc
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/resnet_v1.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/resnet_v1.py
new file mode 100755
index 0000000..81f2a83
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/resnet_v1.py
@@ -0,0 +1,329 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Contains definitions for the original form of Residual Networks.
+
+The 'v1' residual networks (ResNets) implemented in this module were proposed
+by:
+[1] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
+    Deep Residual Learning for Image Recognition. arXiv:1512.03385
+
+Other variants were introduced in:
+[2] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
+    Identity Mappings in Deep Residual Networks. arXiv: 1603.05027
+
+The networks defined in this module utilize the bottleneck building block of
+[1] with projection shortcuts only for increasing depths. They employ batch
+normalization *after* every weight layer. This is the architecture used by
+MSRA in the Imagenet and MSCOCO 2016 competition models ResNet-101 and
+ResNet-152. See [2; Fig. 1a] for a comparison between the current 'v1'
+architecture and the alternative 'v2' architecture of [2] which uses batch
+normalization *before* every weight layer in the so-called full pre-activation
+units.
+
+Typical use:
+
+   from tensorflow.contrib.slim.slim_nets import resnet_v1
+
+ResNet-101 for image classification into 1000 classes:
+
+   # inputs has shape [batch, 224, 224, 3]
+   with slim.arg_scope(resnet_v1.resnet_arg_scope()):
+      net, end_points = resnet_v1.resnet_v1_101(inputs, 1000, is_training=False)
+
+ResNet-101 for semantic segmentation into 21 classes:
+
+   # inputs has shape [batch, 513, 513, 3]
+   with slim.arg_scope(resnet_v1.resnet_arg_scope()):
+      net, end_points = resnet_v1.resnet_v1_101(inputs,
+                                                21,
+                                                is_training=False,
+                                                global_pool=False,
+                                                output_stride=16)
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf
+
+from libs.networks.slim_nets import resnet_utils
+
+
+resnet_arg_scope = resnet_utils.resnet_arg_scope
+slim = tf.contrib.slim
+
+
+@slim.add_arg_scope
+def bottleneck(inputs, depth, depth_bottleneck, stride, rate=1,
+               outputs_collections=None, scope=None):
+  """Bottleneck residual unit variant with BN after convolutions.
+
+  This is the original residual unit proposed in [1]. See Fig. 1(a) of [2] for
+  its definition. Note that we use here the bottleneck variant which has an
+  extra bottleneck layer.
+
+  When putting together two consecutive ResNet blocks that use this unit, one
+  should use stride = 2 in the last unit of the first block.
+
+  Args:
+    inputs: A tensor of size [batch, height, width, channels].
+    depth: The depth of the ResNet unit output.
+    depth_bottleneck: The depth of the bottleneck layers.
+    stride: The ResNet unit's stride. Determines the amount of downsampling of
+      the units output compared to its input.
+    rate: An integer, rate for atrous convolution.
+    outputs_collections: Collection to add the ResNet unit output.
+    scope: Optional variable_scope.
+
+  Returns:
+    The ResNet unit's output.
+  """
+  with tf.variable_scope(scope, 'bottleneck_v1', [inputs]) as sc:
+    depth_in = slim.utils.last_dimension(inputs.get_shape(), min_rank=4)
+    if depth == depth_in:
+      shortcut = resnet_utils.subsample(inputs, stride, 'shortcut')
+    else:
+      shortcut = slim.conv2d(inputs, depth, [1, 1], stride=stride,
+                             activation_fn=None, scope='shortcut')
+
+    residual = slim.conv2d(inputs, depth_bottleneck, [1, 1], stride=1,
+                           scope='conv1')
+    residual = resnet_utils.conv2d_same(residual, depth_bottleneck, 3, stride,
+                                        rate=rate, scope='conv2')
+    residual = slim.conv2d(residual, depth, [1, 1], stride=1,
+                           activation_fn=None, scope='conv3')
+
+    output = tf.nn.relu(shortcut + residual)
+
+    return slim.utils.collect_named_outputs(outputs_collections,
+                                            sc.original_name_scope,
+                                            output)
+
+
+def resnet_v1(inputs,
+              blocks,
+              num_classes=None,
+              is_training=True,
+              global_pool=True,
+              output_stride=None,
+              include_root_block=True,
+              spatial_squeeze=False,
+              reuse=None,
+              scope=None):
+  """Generator for v1 ResNet models.
+
+  This function generates a family of ResNet v1 models. See the resnet_v1_*()
+  methods for specific model instantiations, obtained by selecting different
+  block instantiations that produce ResNets of various depths.
+
+  Training for image classification on Imagenet is usually done with [224, 224]
+  inputs, resulting in [7, 7] feature maps at the output of the last ResNet
+  block for the ResNets defined in [1] that have nominal stride equal to 32.
+  However, for dense prediction tasks we advise that one uses inputs with
+  spatial dimensions that are multiples of 32 plus 1, e.g., [321, 321]. In
+  this case the feature maps at the ResNet output will have spatial shape
+  [(height - 1) / output_stride + 1, (width - 1) / output_stride + 1]
+  and corners exactly aligned with the input image corners, which greatly
+  facilitates alignment of the features to the image. Using as input [225, 225]
+  images results in [8, 8] feature maps at the output of the last ResNet block.
+
+  For dense prediction tasks, the ResNet needs to run in fully-convolutional
+  (FCN) mode and global_pool needs to be set to False. The ResNets in [1, 2] all
+  have nominal stride equal to 32 and a good choice in FCN mode is to use
+  output_stride=16 in order to increase the density of the computed features at
+  small computational and memory overhead, cf. http://arxiv.org/abs/1606.00915.
+
+  Args:
+    inputs: A tensor of size [batch, height_in, width_in, channels].
+    blocks: A list of length equal to the number of ResNet blocks. Each element
+      is a resnet_utils.Block object describing the units in the block.
+    num_classes: Number of predicted classes for classification tasks. If None
+      we return the features before the logit layer.
+    is_training: whether is training or not.
+    global_pool: If True, we perform global average pooling before computing the
+      logits. Set to True for image classification, False for dense prediction.
+    output_stride: If None, then the output will be computed at the nominal
+      network stride. If output_stride is not None, it specifies the requested
+      ratio of input to output spatial resolution.
+    include_root_block: If True, include the initial convolution followed by
+      max-pooling, if False excludes it.
+    spatial_squeeze: if True, logits is of shape [B, C], if false logits is
+        of shape [B, 1, 1, C], where B is batch_size and C is number of classes.
+    reuse: whether or not the network and its variables should be reused. To be
+      able to reuse 'scope' must be given.
+    scope: Optional variable_scope.
+
+  Returns:
+    net: A rank-4 tensor of size [batch, height_out, width_out, channels_out].
+      If global_pool is False, then height_out and width_out are reduced by a
+      factor of output_stride compared to the respective height_in and width_in,
+      else both height_out and width_out equal one. If num_classes is None, then
+      net is the output of the last ResNet block, potentially after global
+      average pooling. If num_classes is not None, net contains the pre-softmax
+      activations.
+    end_points: A dictionary from components of the network to the corresponding
+      activation.
+
+  Raises:
+    ValueError: If the target output_stride is not valid.
+  """
+  with tf.variable_scope(scope, 'resnet_v1', [inputs], reuse=reuse) as sc:
+    end_points_collection = sc.name + '_end_points'
+    with slim.arg_scope([slim.conv2d, bottleneck,
+                         resnet_utils.stack_blocks_dense],
+                        outputs_collections=end_points_collection):
+      with slim.arg_scope([slim.batch_norm], is_training=is_training):
+        net = inputs
+        if include_root_block:
+          if output_stride is not None:
+            if output_stride % 4 != 0:
+              raise ValueError('The output_stride needs to be a multiple of 4.')
+            output_stride /= 4
+          net = resnet_utils.conv2d_same(net, 64, 7, stride=2, scope='conv1')
+          net = slim.max_pool2d(net, [3, 3], stride=2, scope='pool1')
+        net = resnet_utils.stack_blocks_dense(net, blocks, output_stride)
+        if global_pool:
+          # Global average pooling.
+          net = tf.reduce_mean(net, [1, 2], name='pool5', keep_dims=True)
+          # yjr_feature = tf.squeeze(net, [0, 1, 2])
+        if num_classes is not None:
+          net = slim.conv2d(net, num_classes, [1, 1], activation_fn=None,
+                            normalizer_fn=None, scope='logits')
+        if spatial_squeeze:
+          logits = tf.squeeze(net, [1, 2], name='SpatialSqueeze')
+        else:
+          logits = net
+        # Convert end_points_collection into a dictionary of end_points.
+        end_points = slim.utils.convert_collection_to_dict(
+            end_points_collection)
+        if num_classes is not None:
+          end_points['predictions'] = slim.softmax(logits, scope='predictions')
+
+        ###
+        # end_points['yjr_feature'] = yjr_feature
+        return logits, end_points
+resnet_v1.default_image_size = 224
+
+
+def resnet_v1_block(scope, base_depth, num_units, stride):
+  """Helper function for creating a resnet_v1 bottleneck block.
+
+  Args:
+    scope: The scope of the block.
+    base_depth: The depth of the bottleneck layer for each unit.
+    num_units: The number of units in the block.
+    stride: The stride of the block, implemented as a stride in the last unit.
+      All other units have stride=1.
+
+  Returns:
+    A resnet_v1 bottleneck block.
+  """
+  return resnet_utils.Block(scope, bottleneck, [{
+      'depth': base_depth * 4,
+      'depth_bottleneck': base_depth,
+      'stride': 1
+  }] * (num_units - 1) + [{
+      'depth': base_depth * 4,
+      'depth_bottleneck': base_depth,
+      'stride': stride
+  }])
+
+
+def resnet_v1_50(inputs,
+                 num_classes=None,
+                 is_training=True,
+                 global_pool=True,
+                 output_stride=None,
+                 spatial_squeeze=True,
+                 reuse=None,
+                 scope='resnet_v1_50'):
+  """ResNet-50 model of [1]. See resnet_v1() for arg and return description."""
+  blocks = [
+      resnet_v1_block('block1', base_depth=64, num_units=3, stride=2),
+      resnet_v1_block('block2', base_depth=128, num_units=4, stride=2),
+      resnet_v1_block('block3', base_depth=256, num_units=6, stride=2),
+      resnet_v1_block('block4', base_depth=512, num_units=3, stride=1),
+  ]
+  return resnet_v1(inputs, blocks, num_classes, is_training,
+                   global_pool=global_pool, output_stride=output_stride,
+                   include_root_block=True, spatial_squeeze=spatial_squeeze,
+                   reuse=reuse, scope=scope)
+resnet_v1_50.default_image_size = resnet_v1.default_image_size
+
+
+def resnet_v1_101(inputs,
+                  num_classes=None,
+                  is_training=True,
+                  global_pool=True,
+                  output_stride=None,
+                  spatial_squeeze=True,
+                  reuse=None,
+                  scope='resnet_v1_101'):
+  """ResNet-101 model of [1]. See resnet_v1() for arg and return description."""
+  blocks = [
+      resnet_v1_block('block1', base_depth=64, num_units=3, stride=2),
+      resnet_v1_block('block2', base_depth=128, num_units=4, stride=2),
+      resnet_v1_block('block3', base_depth=256, num_units=23, stride=2),
+      resnet_v1_block('block4', base_depth=512, num_units=3, stride=1),
+  ]
+  return resnet_v1(inputs, blocks, num_classes, is_training,
+                   global_pool=global_pool, output_stride=output_stride,
+                   include_root_block=True, spatial_squeeze=spatial_squeeze,
+                   reuse=reuse, scope=scope)
+resnet_v1_101.default_image_size = resnet_v1.default_image_size
+
+
+def resnet_v1_152(inputs,
+                  num_classes=None,
+                  is_training=True,
+                  global_pool=True,
+                  output_stride=None,
+                  spatial_squeeze=True,
+                  reuse=None,
+                  scope='resnet_v1_152'):
+  """ResNet-152 model of [1]. See resnet_v1() for arg and return description."""
+  blocks = [
+      resnet_v1_block('block1', base_depth=64, num_units=3, stride=2),
+      resnet_v1_block('block2', base_depth=128, num_units=8, stride=2),
+      resnet_v1_block('block3', base_depth=256, num_units=36, stride=2),
+      resnet_v1_block('block4', base_depth=512, num_units=3, stride=1),
+  ]
+  return resnet_v1(inputs, blocks, num_classes, is_training,
+                   global_pool=global_pool, output_stride=output_stride,
+                   include_root_block=True, spatial_squeeze=spatial_squeeze,
+                   reuse=reuse, scope=scope)
+resnet_v1_152.default_image_size = resnet_v1.default_image_size
+
+
+def resnet_v1_200(inputs,
+                  num_classes=None,
+                  is_training=True,
+                  global_pool=True,
+                  output_stride=None,
+                  spatial_squeeze=True,
+                  reuse=None,
+                  scope='resnet_v1_200'):
+  """ResNet-200 model of [2]. See resnet_v1() for arg and return description."""
+  blocks = [
+      resnet_v1_block('block1', base_depth=64, num_units=3, stride=2),
+      resnet_v1_block('block2', base_depth=128, num_units=24, stride=2),
+      resnet_v1_block('block3', base_depth=256, num_units=36, stride=2),
+      resnet_v1_block('block4', base_depth=512, num_units=3, stride=1),
+  ]
+  return resnet_v1(inputs, blocks, num_classes, is_training,
+                   global_pool=global_pool, output_stride=output_stride,
+                   include_root_block=True, spatial_squeeze=spatial_squeeze,
+                   reuse=reuse, scope=scope)
+resnet_v1_200.default_image_size = resnet_v1.default_image_size
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/resnet_v1_test.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/resnet_v1_test.py
new file mode 100755
index 0000000..5b27a18
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/resnet_v1_test.py
@@ -0,0 +1,440 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for slim.slim_nets.resnet_v1."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import numpy as np
+import tensorflow as tf
+
+from nets import resnet_utils
+from nets import resnet_v1
+
+slim = tf.contrib.slim
+
+
+def create_test_input(batch_size, height, width, channels):
+  """Create test input tensor.
+
+  Args:
+    batch_size: The number of images per batch or `None` if unknown.
+    height: The height of each image or `None` if unknown.
+    width: The width of each image or `None` if unknown.
+    channels: The number of channels per image or `None` if unknown.
+
+  Returns:
+    Either a placeholder `Tensor` of dimension
+      [batch_size, height, width, channels] if any of the inputs are `None` or a
+    constant `Tensor` with the mesh grid values along the spatial dimensions.
+  """
+  if None in [batch_size, height, width, channels]:
+    return tf.placeholder(tf.float32, (batch_size, height, width, channels))
+  else:
+    return tf.to_float(
+        np.tile(
+            np.reshape(
+                np.reshape(np.arange(height), [height, 1]) +
+                np.reshape(np.arange(width), [1, width]),
+                [1, height, width, 1]),
+            [batch_size, 1, 1, channels]))
+
+
+class ResnetUtilsTest(tf.test.TestCase):
+
+  def testSubsampleThreeByThree(self):
+    x = tf.reshape(tf.to_float(tf.range(9)), [1, 3, 3, 1])
+    x = resnet_utils.subsample(x, 2)
+    expected = tf.reshape(tf.constant([0, 2, 6, 8]), [1, 2, 2, 1])
+    with self.test_session():
+      self.assertAllClose(x.eval(), expected.eval())
+
+  def testSubsampleFourByFour(self):
+    x = tf.reshape(tf.to_float(tf.range(16)), [1, 4, 4, 1])
+    x = resnet_utils.subsample(x, 2)
+    expected = tf.reshape(tf.constant([0, 2, 8, 10]), [1, 2, 2, 1])
+    with self.test_session():
+      self.assertAllClose(x.eval(), expected.eval())
+
+  def testConv2DSameEven(self):
+    n, n2 = 4, 2
+
+    # Input image.
+    x = create_test_input(1, n, n, 1)
+
+    # Convolution kernel.
+    w = create_test_input(1, 3, 3, 1)
+    w = tf.reshape(w, [3, 3, 1, 1])
+
+    tf.get_variable('Conv/weights', initializer=w)
+    tf.get_variable('Conv/biases', initializer=tf.zeros([1]))
+    tf.get_variable_scope().reuse_variables()
+
+    y1 = slim.conv2d(x, 1, [3, 3], stride=1, scope='Conv')
+    y1_expected = tf.to_float([[14, 28, 43, 26],
+                               [28, 48, 66, 37],
+                               [43, 66, 84, 46],
+                               [26, 37, 46, 22]])
+    y1_expected = tf.reshape(y1_expected, [1, n, n, 1])
+
+    y2 = resnet_utils.subsample(y1, 2)
+    y2_expected = tf.to_float([[14, 43],
+                               [43, 84]])
+    y2_expected = tf.reshape(y2_expected, [1, n2, n2, 1])
+
+    y3 = resnet_utils.conv2d_same(x, 1, 3, stride=2, scope='Conv')
+    y3_expected = y2_expected
+
+    y4 = slim.conv2d(x, 1, [3, 3], stride=2, scope='Conv')
+    y4_expected = tf.to_float([[48, 37],
+                               [37, 22]])
+    y4_expected = tf.reshape(y4_expected, [1, n2, n2, 1])
+
+    with self.test_session() as sess:
+      sess.run(tf.global_variables_initializer())
+      self.assertAllClose(y1.eval(), y1_expected.eval())
+      self.assertAllClose(y2.eval(), y2_expected.eval())
+      self.assertAllClose(y3.eval(), y3_expected.eval())
+      self.assertAllClose(y4.eval(), y4_expected.eval())
+
+  def testConv2DSameOdd(self):
+    n, n2 = 5, 3
+
+    # Input image.
+    x = create_test_input(1, n, n, 1)
+
+    # Convolution kernel.
+    w = create_test_input(1, 3, 3, 1)
+    w = tf.reshape(w, [3, 3, 1, 1])
+
+    tf.get_variable('Conv/weights', initializer=w)
+    tf.get_variable('Conv/biases', initializer=tf.zeros([1]))
+    tf.get_variable_scope().reuse_variables()
+
+    y1 = slim.conv2d(x, 1, [3, 3], stride=1, scope='Conv')
+    y1_expected = tf.to_float([[14, 28, 43, 58, 34],
+                               [28, 48, 66, 84, 46],
+                               [43, 66, 84, 102, 55],
+                               [58, 84, 102, 120, 64],
+                               [34, 46, 55, 64, 30]])
+    y1_expected = tf.reshape(y1_expected, [1, n, n, 1])
+
+    y2 = resnet_utils.subsample(y1, 2)
+    y2_expected = tf.to_float([[14, 43, 34],
+                               [43, 84, 55],
+                               [34, 55, 30]])
+    y2_expected = tf.reshape(y2_expected, [1, n2, n2, 1])
+
+    y3 = resnet_utils.conv2d_same(x, 1, 3, stride=2, scope='Conv')
+    y3_expected = y2_expected
+
+    y4 = slim.conv2d(x, 1, [3, 3], stride=2, scope='Conv')
+    y4_expected = y2_expected
+
+    with self.test_session() as sess:
+      sess.run(tf.global_variables_initializer())
+      self.assertAllClose(y1.eval(), y1_expected.eval())
+      self.assertAllClose(y2.eval(), y2_expected.eval())
+      self.assertAllClose(y3.eval(), y3_expected.eval())
+      self.assertAllClose(y4.eval(), y4_expected.eval())
+
+  def _resnet_plain(self, inputs, blocks, output_stride=None, scope=None):
+    """A plain ResNet without extra layers before or after the ResNet blocks."""
+    with tf.variable_scope(scope, values=[inputs]):
+      with slim.arg_scope([slim.conv2d], outputs_collections='end_points'):
+        net = resnet_utils.stack_blocks_dense(inputs, blocks, output_stride)
+        end_points = slim.utils.convert_collection_to_dict('end_points')
+        return net, end_points
+
+  def testEndPointsV1(self):
+    """Test the end points of a tiny v1 bottleneck network."""
+    blocks = [
+        resnet_v1.resnet_v1_block(
+            'block1', base_depth=1, num_units=2, stride=2),
+        resnet_v1.resnet_v1_block(
+            'block2', base_depth=2, num_units=2, stride=1),
+    ]
+    inputs = create_test_input(2, 32, 16, 3)
+    with slim.arg_scope(resnet_utils.resnet_arg_scope()):
+      _, end_points = self._resnet_plain(inputs, blocks, scope='tiny')
+    expected = [
+        'tiny/block1/unit_1/bottleneck_v1/shortcut',
+        'tiny/block1/unit_1/bottleneck_v1/conv1',
+        'tiny/block1/unit_1/bottleneck_v1/conv2',
+        'tiny/block1/unit_1/bottleneck_v1/conv3',
+        'tiny/block1/unit_2/bottleneck_v1/conv1',
+        'tiny/block1/unit_2/bottleneck_v1/conv2',
+        'tiny/block1/unit_2/bottleneck_v1/conv3',
+        'tiny/block2/unit_1/bottleneck_v1/shortcut',
+        'tiny/block2/unit_1/bottleneck_v1/conv1',
+        'tiny/block2/unit_1/bottleneck_v1/conv2',
+        'tiny/block2/unit_1/bottleneck_v1/conv3',
+        'tiny/block2/unit_2/bottleneck_v1/conv1',
+        'tiny/block2/unit_2/bottleneck_v1/conv2',
+        'tiny/block2/unit_2/bottleneck_v1/conv3']
+    self.assertItemsEqual(expected, end_points)
+
+  def _stack_blocks_nondense(self, net, blocks):
+    """A simplified ResNet Block stacker without output stride control."""
+    for block in blocks:
+      with tf.variable_scope(block.scope, 'block', [net]):
+        for i, unit in enumerate(block.args):
+          with tf.variable_scope('unit_%d' % (i + 1), values=[net]):
+            net = block.unit_fn(net, rate=1, **unit)
+    return net
+
+  def testAtrousValuesBottleneck(self):
+    """Verify the values of dense feature extraction by atrous convolution.
+
+    Make sure that dense feature extraction by stack_blocks_dense() followed by
+    subsampling gives identical results to feature extraction at the nominal
+    network output stride using the simple self._stack_blocks_nondense() above.
+    """
+    block = resnet_v1.resnet_v1_block
+    blocks = [
+        block('block1', base_depth=1, num_units=2, stride=2),
+        block('block2', base_depth=2, num_units=2, stride=2),
+        block('block3', base_depth=4, num_units=2, stride=2),
+        block('block4', base_depth=8, num_units=2, stride=1),
+    ]
+    nominal_stride = 8
+
+    # Test both odd and even input dimensions.
+    height = 30
+    width = 31
+    with slim.arg_scope(resnet_utils.resnet_arg_scope()):
+      with slim.arg_scope([slim.batch_norm], is_training=False):
+        for output_stride in [1, 2, 4, 8, None]:
+          with tf.Graph().as_default():
+            with self.test_session() as sess:
+              tf.set_random_seed(0)
+              inputs = create_test_input(1, height, width, 3)
+              # Dense feature extraction followed by subsampling.
+              output = resnet_utils.stack_blocks_dense(inputs,
+                                                       blocks,
+                                                       output_stride)
+              if output_stride is None:
+                factor = 1
+              else:
+                factor = nominal_stride // output_stride
+
+              output = resnet_utils.subsample(output, factor)
+              # Make the two networks use the same weights.
+              tf.get_variable_scope().reuse_variables()
+              # Feature extraction at the nominal network rate.
+              expected = self._stack_blocks_nondense(inputs, blocks)
+              sess.run(tf.global_variables_initializer())
+              output, expected = sess.run([output, expected])
+              self.assertAllClose(output, expected, atol=1e-4, rtol=1e-4)
+
+
+class ResnetCompleteNetworkTest(tf.test.TestCase):
+  """Tests with complete small ResNet v1 networks."""
+
+  def _resnet_small(self,
+                    inputs,
+                    num_classes=None,
+                    is_training=True,
+                    global_pool=True,
+                    output_stride=None,
+                    include_root_block=True,
+                    reuse=None,
+                    scope='resnet_v1_small'):
+    """A shallow and thin ResNet v1 for faster tests."""
+    block = resnet_v1.resnet_v1_block
+    blocks = [
+        block('block1', base_depth=1, num_units=3, stride=2),
+        block('block2', base_depth=2, num_units=3, stride=2),
+        block('block3', base_depth=4, num_units=3, stride=2),
+        block('block4', base_depth=8, num_units=2, stride=1),
+    ]
+    return resnet_v1.resnet_v1(inputs, blocks, num_classes,
+                               is_training=is_training,
+                               global_pool=global_pool,
+                               output_stride=output_stride,
+                               include_root_block=include_root_block,
+                               reuse=reuse,
+                               scope=scope)
+
+  def testClassificationEndPoints(self):
+    global_pool = True
+    num_classes = 10
+    inputs = create_test_input(2, 224, 224, 3)
+    with slim.arg_scope(resnet_utils.resnet_arg_scope()):
+      logits, end_points = self._resnet_small(inputs, num_classes,
+                                              global_pool=global_pool,
+                                              scope='resnet')
+    self.assertTrue(logits.op.name.startswith('resnet/logits'))
+    self.assertListEqual(logits.get_shape().as_list(), [2, 1, 1, num_classes])
+    self.assertTrue('predictions' in end_points)
+    self.assertListEqual(end_points['predictions'].get_shape().as_list(),
+                         [2, 1, 1, num_classes])
+
+  def testClassificationShapes(self):
+    global_pool = True
+    num_classes = 10
+    inputs = create_test_input(2, 224, 224, 3)
+    with slim.arg_scope(resnet_utils.resnet_arg_scope()):
+      _, end_points = self._resnet_small(inputs, num_classes,
+                                         global_pool=global_pool,
+                                         scope='resnet')
+      endpoint_to_shape = {
+          'resnet/block1': [2, 28, 28, 4],
+          'resnet/block2': [2, 14, 14, 8],
+          'resnet/block3': [2, 7, 7, 16],
+          'resnet/block4': [2, 7, 7, 32]}
+      for endpoint in endpoint_to_shape:
+        shape = endpoint_to_shape[endpoint]
+        self.assertListEqual(end_points[endpoint].get_shape().as_list(), shape)
+
+  def testFullyConvolutionalEndpointShapes(self):
+    global_pool = False
+    num_classes = 10
+    inputs = create_test_input(2, 321, 321, 3)
+    with slim.arg_scope(resnet_utils.resnet_arg_scope()):
+      _, end_points = self._resnet_small(inputs, num_classes,
+                                         global_pool=global_pool,
+                                         scope='resnet')
+      endpoint_to_shape = {
+          'resnet/block1': [2, 41, 41, 4],
+          'resnet/block2': [2, 21, 21, 8],
+          'resnet/block3': [2, 11, 11, 16],
+          'resnet/block4': [2, 11, 11, 32]}
+      for endpoint in endpoint_to_shape:
+        shape = endpoint_to_shape[endpoint]
+        self.assertListEqual(end_points[endpoint].get_shape().as_list(), shape)
+
+  def testRootlessFullyConvolutionalEndpointShapes(self):
+    global_pool = False
+    num_classes = 10
+    inputs = create_test_input(2, 128, 128, 3)
+    with slim.arg_scope(resnet_utils.resnet_arg_scope()):
+      _, end_points = self._resnet_small(inputs, num_classes,
+                                         global_pool=global_pool,
+                                         include_root_block=False,
+                                         scope='resnet')
+      endpoint_to_shape = {
+          'resnet/block1': [2, 64, 64, 4],
+          'resnet/block2': [2, 32, 32, 8],
+          'resnet/block3': [2, 16, 16, 16],
+          'resnet/block4': [2, 16, 16, 32]}
+      for endpoint in endpoint_to_shape:
+        shape = endpoint_to_shape[endpoint]
+        self.assertListEqual(end_points[endpoint].get_shape().as_list(), shape)
+
+  def testAtrousFullyConvolutionalEndpointShapes(self):
+    global_pool = False
+    num_classes = 10
+    output_stride = 8
+    inputs = create_test_input(2, 321, 321, 3)
+    with slim.arg_scope(resnet_utils.resnet_arg_scope()):
+      _, end_points = self._resnet_small(inputs,
+                                         num_classes,
+                                         global_pool=global_pool,
+                                         output_stride=output_stride,
+                                         scope='resnet')
+      endpoint_to_shape = {
+          'resnet/block1': [2, 41, 41, 4],
+          'resnet/block2': [2, 41, 41, 8],
+          'resnet/block3': [2, 41, 41, 16],
+          'resnet/block4': [2, 41, 41, 32]}
+      for endpoint in endpoint_to_shape:
+        shape = endpoint_to_shape[endpoint]
+        self.assertListEqual(end_points[endpoint].get_shape().as_list(), shape)
+
+  def testAtrousFullyConvolutionalValues(self):
+    """Verify dense feature extraction with atrous convolution."""
+    nominal_stride = 32
+    for output_stride in [4, 8, 16, 32, None]:
+      with slim.arg_scope(resnet_utils.resnet_arg_scope()):
+        with tf.Graph().as_default():
+          with self.test_session() as sess:
+            tf.set_random_seed(0)
+            inputs = create_test_input(2, 81, 81, 3)
+            # Dense feature extraction followed by subsampling.
+            output, _ = self._resnet_small(inputs, None, is_training=False,
+                                           global_pool=False,
+                                           output_stride=output_stride)
+            if output_stride is None:
+              factor = 1
+            else:
+              factor = nominal_stride // output_stride
+            output = resnet_utils.subsample(output, factor)
+            # Make the two networks use the same weights.
+            tf.get_variable_scope().reuse_variables()
+            # Feature extraction at the nominal network rate.
+            expected, _ = self._resnet_small(inputs, None, is_training=False,
+                                             global_pool=False)
+            sess.run(tf.global_variables_initializer())
+            self.assertAllClose(output.eval(), expected.eval(),
+                                atol=1e-4, rtol=1e-4)
+
+  def testUnknownBatchSize(self):
+    batch = 2
+    height, width = 65, 65
+    global_pool = True
+    num_classes = 10
+    inputs = create_test_input(None, height, width, 3)
+    with slim.arg_scope(resnet_utils.resnet_arg_scope()):
+      logits, _ = self._resnet_small(inputs, num_classes,
+                                     global_pool=global_pool,
+                                     scope='resnet')
+    self.assertTrue(logits.op.name.startswith('resnet/logits'))
+    self.assertListEqual(logits.get_shape().as_list(),
+                         [None, 1, 1, num_classes])
+    images = create_test_input(batch, height, width, 3)
+    with self.test_session() as sess:
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(logits, {inputs: images.eval()})
+      self.assertEqual(output.shape, (batch, 1, 1, num_classes))
+
+  def testFullyConvolutionalUnknownHeightWidth(self):
+    batch = 2
+    height, width = 65, 65
+    global_pool = False
+    inputs = create_test_input(batch, None, None, 3)
+    with slim.arg_scope(resnet_utils.resnet_arg_scope()):
+      output, _ = self._resnet_small(inputs, None, global_pool=global_pool)
+    self.assertListEqual(output.get_shape().as_list(),
+                         [batch, None, None, 32])
+    images = create_test_input(batch, height, width, 3)
+    with self.test_session() as sess:
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(output, {inputs: images.eval()})
+      self.assertEqual(output.shape, (batch, 3, 3, 32))
+
+  def testAtrousFullyConvolutionalUnknownHeightWidth(self):
+    batch = 2
+    height, width = 65, 65
+    global_pool = False
+    output_stride = 8
+    inputs = create_test_input(batch, None, None, 3)
+    with slim.arg_scope(resnet_utils.resnet_arg_scope()):
+      output, _ = self._resnet_small(inputs,
+                                     None,
+                                     global_pool=global_pool,
+                                     output_stride=output_stride)
+    self.assertListEqual(output.get_shape().as_list(),
+                         [batch, None, None, 32])
+    images = create_test_input(batch, height, width, 3)
+    with self.test_session() as sess:
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(output, {inputs: images.eval()})
+      self.assertEqual(output.shape, (batch, 9, 9, 32))
+
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/resnet_v2.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/resnet_v2.py
new file mode 100755
index 0000000..7617701
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/resnet_v2.py
@@ -0,0 +1,333 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Contains definitions for the preactivation form of Residual Networks.
+
+Residual networks (ResNets) were originally proposed in:
+[1] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
+    Deep Residual Learning for Image Recognition. arXiv:1512.03385
+
+The full preactivation 'v2' ResNet variant implemented in this module was
+introduced by:
+[2] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
+    Identity Mappings in Deep Residual Networks. arXiv: 1603.05027
+
+The key difference of the full preactivation 'v2' variant compared to the
+'v1' variant in [1] is the use of batch normalization before every weight layer.
+
+Typical use:
+
+   from tensorflow.contrib.slim.slim_nets import resnet_v2
+
+ResNet-101 for image classification into 1000 classes:
+
+   # inputs has shape [batch, 224, 224, 3]
+   with slim.arg_scope(resnet_v2.resnet_arg_scope()):
+      net, end_points = resnet_v2.resnet_v2_101(inputs, 1000, is_training=False)
+
+ResNet-101 for semantic segmentation into 21 classes:
+
+   # inputs has shape [batch, 513, 513, 3]
+   with slim.arg_scope(resnet_v2.resnet_arg_scope(is_training)):
+      net, end_points = resnet_v2.resnet_v2_101(inputs,
+                                                21,
+                                                is_training=False,
+                                                global_pool=False,
+                                                output_stride=16)
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf
+
+from nets import resnet_utils
+
+slim = tf.contrib.slim
+resnet_arg_scope = resnet_utils.resnet_arg_scope
+
+
+@slim.add_arg_scope
+def bottleneck(inputs, depth, depth_bottleneck, stride, rate=1,
+               outputs_collections=None, scope=None):
+  """Bottleneck residual unit variant with BN before convolutions.
+
+  This is the full preactivation residual unit variant proposed in [2]. See
+  Fig. 1(b) of [2] for its definition. Note that we use here the bottleneck
+  variant which has an extra bottleneck layer.
+
+  When putting together two consecutive ResNet blocks that use this unit, one
+  should use stride = 2 in the last unit of the first block.
+
+  Args:
+    inputs: A tensor of size [batch, height, width, channels].
+    depth: The depth of the ResNet unit output.
+    depth_bottleneck: The depth of the bottleneck layers.
+    stride: The ResNet unit's stride. Determines the amount of downsampling of
+      the units output compared to its input.
+    rate: An integer, rate for atrous convolution.
+    outputs_collections: Collection to add the ResNet unit output.
+    scope: Optional variable_scope.
+
+  Returns:
+    The ResNet unit's output.
+  """
+  with tf.variable_scope(scope, 'bottleneck_v2', [inputs]) as sc:
+    depth_in = slim.utils.last_dimension(inputs.get_shape(), min_rank=4)
+    preact = slim.batch_norm(inputs, activation_fn=tf.nn.relu, scope='preact')
+    if depth == depth_in:
+      shortcut = resnet_utils.subsample(inputs, stride, 'shortcut')
+    else:
+      shortcut = slim.conv2d(preact, depth, [1, 1], stride=stride,
+                             normalizer_fn=None, activation_fn=None,
+                             scope='shortcut')
+
+    residual = slim.conv2d(preact, depth_bottleneck, [1, 1], stride=1,
+                           scope='conv1')
+    residual = resnet_utils.conv2d_same(residual, depth_bottleneck, 3, stride,
+                                        rate=rate, scope='conv2')
+    residual = slim.conv2d(residual, depth, [1, 1], stride=1,
+                           normalizer_fn=None, activation_fn=None,
+                           scope='conv3')
+
+    output = shortcut + residual
+
+    return slim.utils.collect_named_outputs(outputs_collections,
+                                            sc.original_name_scope,
+                                            output)
+
+
+def resnet_v2(inputs,
+              blocks,
+              num_classes=None,
+              is_training=True,
+              global_pool=True,
+              output_stride=None,
+              include_root_block=True,
+              spatial_squeeze=False,
+              reuse=None,
+              scope=None):
+  """Generator for v2 (preactivation) ResNet models.
+
+  This function generates a family of ResNet v2 models. See the resnet_v2_*()
+  methods for specific model instantiations, obtained by selecting different
+  block instantiations that produce ResNets of various depths.
+
+  Training for image classification on Imagenet is usually done with [224, 224]
+  inputs, resulting in [7, 7] feature maps at the output of the last ResNet
+  block for the ResNets defined in [1] that have nominal stride equal to 32.
+  However, for dense prediction tasks we advise that one uses inputs with
+  spatial dimensions that are multiples of 32 plus 1, e.g., [321, 321]. In
+  this case the feature maps at the ResNet output will have spatial shape
+  [(height - 1) / output_stride + 1, (width - 1) / output_stride + 1]
+  and corners exactly aligned with the input image corners, which greatly
+  facilitates alignment of the features to the image. Using as input [225, 225]
+  images results in [8, 8] feature maps at the output of the last ResNet block.
+
+  For dense prediction tasks, the ResNet needs to run in fully-convolutional
+  (FCN) mode and global_pool needs to be set to False. The ResNets in [1, 2] all
+  have nominal stride equal to 32 and a good choice in FCN mode is to use
+  output_stride=16 in order to increase the density of the computed features at
+  small computational and memory overhead, cf. http://arxiv.org/abs/1606.00915.
+
+  Args:
+    inputs: A tensor of size [batch, height_in, width_in, channels].
+    blocks: A list of length equal to the number of ResNet blocks. Each element
+      is a resnet_utils.Block object describing the units in the block.
+    num_classes: Number of predicted classes for classification tasks. If None
+      we return the features before the logit layer.
+    is_training: whether is training or not.
+    global_pool: If True, we perform global average pooling before computing the
+      logits. Set to True for image classification, False for dense prediction.
+    output_stride: If None, then the output will be computed at the nominal
+      network stride. If output_stride is not None, it specifies the requested
+      ratio of input to output spatial resolution.
+    include_root_block: If True, include the initial convolution followed by
+      max-pooling, if False excludes it. If excluded, `inputs` should be the
+      results of an activation-less convolution.
+    spatial_squeeze: if True, logits is of shape [B, C], if false logits is
+        of shape [B, 1, 1, C], where B is batch_size and C is number of classes.
+    reuse: whether or not the network and its variables should be reused. To be
+      able to reuse 'scope' must be given.
+    scope: Optional variable_scope.
+
+
+  Returns:
+    net: A rank-4 tensor of size [batch, height_out, width_out, channels_out].
+      If global_pool is False, then height_out and width_out are reduced by a
+      factor of output_stride compared to the respective height_in and width_in,
+      else both height_out and width_out equal one. If num_classes is None, then
+      net is the output of the last ResNet block, potentially after global
+      average pooling. If num_classes is not None, net contains the pre-softmax
+      activations.
+    end_points: A dictionary from components of the network to the corresponding
+      activation.
+
+  Raises:
+    ValueError: If the target output_stride is not valid.
+  """
+  with tf.variable_scope(scope, 'resnet_v2', [inputs], reuse=reuse) as sc:
+    end_points_collection = sc.name + '_end_points'
+    with slim.arg_scope([slim.conv2d, bottleneck,
+                         resnet_utils.stack_blocks_dense],
+                        outputs_collections=end_points_collection):
+      with slim.arg_scope([slim.batch_norm], is_training=is_training):
+        net = inputs
+        if include_root_block:
+          if output_stride is not None:
+            if output_stride % 4 != 0:
+              raise ValueError('The output_stride needs to be a multiple of 4.')
+            output_stride /= 4
+          # We do not include batch normalization or activation functions in
+          # conv1 because the first ResNet unit will perform these. Cf.
+          # Appendix of [2].
+          with slim.arg_scope([slim.conv2d],
+                              activation_fn=None, normalizer_fn=None):
+            net = resnet_utils.conv2d_same(net, 64, 7, stride=2, scope='conv1')
+          net = slim.max_pool2d(net, [3, 3], stride=2, scope='pool1')
+        net = resnet_utils.stack_blocks_dense(net, blocks, output_stride)
+        # This is needed because the pre-activation variant does not have batch
+        # normalization or activation functions in the residual unit output. See
+        # Appendix of [2].
+        net = slim.batch_norm(net, activation_fn=tf.nn.relu, scope='postnorm')
+        if global_pool:
+          # Global average pooling.
+          net = tf.reduce_mean(net, [1, 2], name='pool5', keep_dims=True)
+        if num_classes is not None:
+          net = slim.conv2d(net, num_classes, [1, 1], activation_fn=None,
+                            normalizer_fn=None, scope='logits')
+        if spatial_squeeze:
+          logits = tf.squeeze(net, [1, 2], name='SpatialSqueeze')
+        else:
+          logits = net
+        # Convert end_points_collection into a dictionary of end_points.
+        end_points = slim.utils.convert_collection_to_dict(
+            end_points_collection)
+        if num_classes is not None:
+          end_points['predictions'] = slim.softmax(logits, scope='predictions')
+        return logits, end_points
+resnet_v2.default_image_size = 224
+
+
+def resnet_v2_block(scope, base_depth, num_units, stride):
+  """Helper function for creating a resnet_v2 bottleneck block.
+
+  Args:
+    scope: The scope of the block.
+    base_depth: The depth of the bottleneck layer for each unit.
+    num_units: The number of units in the block.
+    stride: The stride of the block, implemented as a stride in the last unit.
+      All other units have stride=1.
+
+  Returns:
+    A resnet_v2 bottleneck block.
+  """
+  return resnet_utils.Block(scope, bottleneck, [{
+      'depth': base_depth * 4,
+      'depth_bottleneck': base_depth,
+      'stride': 1
+  }] * (num_units - 1) + [{
+      'depth': base_depth * 4,
+      'depth_bottleneck': base_depth,
+      'stride': stride
+  }])
+resnet_v2.default_image_size = 224
+
+
+def resnet_v2_50(inputs,
+                 num_classes=None,
+                 is_training=True,
+                 global_pool=True,
+                 output_stride=None,
+                 spatial_squeeze=False,
+                 reuse=None,
+                 scope='resnet_v2_50'):
+  """ResNet-50 model of [1]. See resnet_v2() for arg and return description."""
+  blocks = [
+      resnet_v2_block('block1', base_depth=64, num_units=3, stride=2),
+      resnet_v2_block('block2', base_depth=128, num_units=4, stride=2),
+      resnet_v2_block('block3', base_depth=256, num_units=6, stride=2),
+      resnet_v2_block('block4', base_depth=512, num_units=3, stride=1),
+  ]
+  return resnet_v2(inputs, blocks, num_classes, is_training=is_training,
+                   global_pool=global_pool, output_stride=output_stride,
+                   include_root_block=True, spatial_squeeze=spatial_squeeze,
+                   reuse=reuse, scope=scope)
+resnet_v2_50.default_image_size = resnet_v2.default_image_size
+
+
+def resnet_v2_101(inputs,
+                  num_classes=None,
+                  is_training=True,
+                  global_pool=True,
+                  output_stride=None,
+                  spatial_squeeze=False,
+                  reuse=None,
+                  scope='resnet_v2_101'):
+  """ResNet-101 model of [1]. See resnet_v2() for arg and return description."""
+  blocks = [
+      resnet_v2_block('block1', base_depth=64, num_units=3, stride=2),
+      resnet_v2_block('block2', base_depth=128, num_units=4, stride=2),
+      resnet_v2_block('block3', base_depth=256, num_units=23, stride=2),
+      resnet_v2_block('block4', base_depth=512, num_units=3, stride=1),
+  ]
+  return resnet_v2(inputs, blocks, num_classes, is_training=is_training,
+                   global_pool=global_pool, output_stride=output_stride,
+                   include_root_block=True, spatial_squeeze=spatial_squeeze,
+                   reuse=reuse, scope=scope)
+resnet_v2_101.default_image_size = resnet_v2.default_image_size
+
+
+def resnet_v2_152(inputs,
+                  num_classes=None,
+                  is_training=True,
+                  global_pool=True,
+                  output_stride=None,
+                  spatial_squeeze=False,
+                  reuse=None,
+                  scope='resnet_v2_152'):
+  """ResNet-152 model of [1]. See resnet_v2() for arg and return description."""
+  blocks = [
+      resnet_v2_block('block1', base_depth=64, num_units=3, stride=2),
+      resnet_v2_block('block2', base_depth=128, num_units=8, stride=2),
+      resnet_v2_block('block3', base_depth=256, num_units=36, stride=2),
+      resnet_v2_block('block4', base_depth=512, num_units=3, stride=1),
+  ]
+  return resnet_v2(inputs, blocks, num_classes, is_training=is_training,
+                   global_pool=global_pool, output_stride=output_stride,
+                   include_root_block=True, spatial_squeeze=spatial_squeeze,
+                   reuse=reuse, scope=scope)
+resnet_v2_152.default_image_size = resnet_v2.default_image_size
+
+
+def resnet_v2_200(inputs,
+                  num_classes=None,
+                  is_training=True,
+                  global_pool=True,
+                  output_stride=None,
+                  spatial_squeeze=False,
+                  reuse=None,
+                  scope='resnet_v2_200'):
+  """ResNet-200 model of [2]. See resnet_v2() for arg and return description."""
+  blocks = [
+      resnet_v2_block('block1', base_depth=64, num_units=3, stride=2),
+      resnet_v2_block('block2', base_depth=128, num_units=24, stride=2),
+      resnet_v2_block('block3', base_depth=256, num_units=36, stride=2),
+      resnet_v2_block('block4', base_depth=512, num_units=3, stride=1),
+  ]
+  return resnet_v2(inputs, blocks, num_classes, is_training=is_training,
+                   global_pool=global_pool, output_stride=output_stride,
+                   include_root_block=True, spatial_squeeze=spatial_squeeze,
+                   reuse=reuse, scope=scope)
+resnet_v2_200.default_image_size = resnet_v2.default_image_size
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/resnet_v2_test.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/resnet_v2_test.py
new file mode 100755
index 0000000..c181664
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/resnet_v2_test.py
@@ -0,0 +1,443 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for slim.slim_nets.resnet_v2."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import numpy as np
+import tensorflow as tf
+
+from nets import resnet_utils
+from nets import resnet_v2
+
+slim = tf.contrib.slim
+
+
+def create_test_input(batch_size, height, width, channels):
+  """Create test input tensor.
+
+  Args:
+    batch_size: The number of images per batch or `None` if unknown.
+    height: The height of each image or `None` if unknown.
+    width: The width of each image or `None` if unknown.
+    channels: The number of channels per image or `None` if unknown.
+
+  Returns:
+    Either a placeholder `Tensor` of dimension
+      [batch_size, height, width, channels] if any of the inputs are `None` or a
+    constant `Tensor` with the mesh grid values along the spatial dimensions.
+  """
+  if None in [batch_size, height, width, channels]:
+    return tf.placeholder(tf.float32, (batch_size, height, width, channels))
+  else:
+    return tf.to_float(
+        np.tile(
+            np.reshape(
+                np.reshape(np.arange(height), [height, 1]) +
+                np.reshape(np.arange(width), [1, width]),
+                [1, height, width, 1]),
+            [batch_size, 1, 1, channels]))
+
+
+class ResnetUtilsTest(tf.test.TestCase):
+
+  def testSubsampleThreeByThree(self):
+    x = tf.reshape(tf.to_float(tf.range(9)), [1, 3, 3, 1])
+    x = resnet_utils.subsample(x, 2)
+    expected = tf.reshape(tf.constant([0, 2, 6, 8]), [1, 2, 2, 1])
+    with self.test_session():
+      self.assertAllClose(x.eval(), expected.eval())
+
+  def testSubsampleFourByFour(self):
+    x = tf.reshape(tf.to_float(tf.range(16)), [1, 4, 4, 1])
+    x = resnet_utils.subsample(x, 2)
+    expected = tf.reshape(tf.constant([0, 2, 8, 10]), [1, 2, 2, 1])
+    with self.test_session():
+      self.assertAllClose(x.eval(), expected.eval())
+
+  def testConv2DSameEven(self):
+    n, n2 = 4, 2
+
+    # Input image.
+    x = create_test_input(1, n, n, 1)
+
+    # Convolution kernel.
+    w = create_test_input(1, 3, 3, 1)
+    w = tf.reshape(w, [3, 3, 1, 1])
+
+    tf.get_variable('Conv/weights', initializer=w)
+    tf.get_variable('Conv/biases', initializer=tf.zeros([1]))
+    tf.get_variable_scope().reuse_variables()
+
+    y1 = slim.conv2d(x, 1, [3, 3], stride=1, scope='Conv')
+    y1_expected = tf.to_float([[14, 28, 43, 26],
+                               [28, 48, 66, 37],
+                               [43, 66, 84, 46],
+                               [26, 37, 46, 22]])
+    y1_expected = tf.reshape(y1_expected, [1, n, n, 1])
+
+    y2 = resnet_utils.subsample(y1, 2)
+    y2_expected = tf.to_float([[14, 43],
+                               [43, 84]])
+    y2_expected = tf.reshape(y2_expected, [1, n2, n2, 1])
+
+    y3 = resnet_utils.conv2d_same(x, 1, 3, stride=2, scope='Conv')
+    y3_expected = y2_expected
+
+    y4 = slim.conv2d(x, 1, [3, 3], stride=2, scope='Conv')
+    y4_expected = tf.to_float([[48, 37],
+                               [37, 22]])
+    y4_expected = tf.reshape(y4_expected, [1, n2, n2, 1])
+
+    with self.test_session() as sess:
+      sess.run(tf.global_variables_initializer())
+      self.assertAllClose(y1.eval(), y1_expected.eval())
+      self.assertAllClose(y2.eval(), y2_expected.eval())
+      self.assertAllClose(y3.eval(), y3_expected.eval())
+      self.assertAllClose(y4.eval(), y4_expected.eval())
+
+  def testConv2DSameOdd(self):
+    n, n2 = 5, 3
+
+    # Input image.
+    x = create_test_input(1, n, n, 1)
+
+    # Convolution kernel.
+    w = create_test_input(1, 3, 3, 1)
+    w = tf.reshape(w, [3, 3, 1, 1])
+
+    tf.get_variable('Conv/weights', initializer=w)
+    tf.get_variable('Conv/biases', initializer=tf.zeros([1]))
+    tf.get_variable_scope().reuse_variables()
+
+    y1 = slim.conv2d(x, 1, [3, 3], stride=1, scope='Conv')
+    y1_expected = tf.to_float([[14, 28, 43, 58, 34],
+                               [28, 48, 66, 84, 46],
+                               [43, 66, 84, 102, 55],
+                               [58, 84, 102, 120, 64],
+                               [34, 46, 55, 64, 30]])
+    y1_expected = tf.reshape(y1_expected, [1, n, n, 1])
+
+    y2 = resnet_utils.subsample(y1, 2)
+    y2_expected = tf.to_float([[14, 43, 34],
+                               [43, 84, 55],
+                               [34, 55, 30]])
+    y2_expected = tf.reshape(y2_expected, [1, n2, n2, 1])
+
+    y3 = resnet_utils.conv2d_same(x, 1, 3, stride=2, scope='Conv')
+    y3_expected = y2_expected
+
+    y4 = slim.conv2d(x, 1, [3, 3], stride=2, scope='Conv')
+    y4_expected = y2_expected
+
+    with self.test_session() as sess:
+      sess.run(tf.global_variables_initializer())
+      self.assertAllClose(y1.eval(), y1_expected.eval())
+      self.assertAllClose(y2.eval(), y2_expected.eval())
+      self.assertAllClose(y3.eval(), y3_expected.eval())
+      self.assertAllClose(y4.eval(), y4_expected.eval())
+
+  def _resnet_plain(self, inputs, blocks, output_stride=None, scope=None):
+    """A plain ResNet without extra layers before or after the ResNet blocks."""
+    with tf.variable_scope(scope, values=[inputs]):
+      with slim.arg_scope([slim.conv2d], outputs_collections='end_points'):
+        net = resnet_utils.stack_blocks_dense(inputs, blocks, output_stride)
+        end_points = slim.utils.convert_collection_to_dict('end_points')
+        return net, end_points
+
+  def testEndPointsV2(self):
+    """Test the end points of a tiny v2 bottleneck network."""
+    blocks = [
+        resnet_v2.resnet_v2_block(
+            'block1', base_depth=1, num_units=2, stride=2),
+        resnet_v2.resnet_v2_block(
+            'block2', base_depth=2, num_units=2, stride=1),
+    ]
+    inputs = create_test_input(2, 32, 16, 3)
+    with slim.arg_scope(resnet_utils.resnet_arg_scope()):
+      _, end_points = self._resnet_plain(inputs, blocks, scope='tiny')
+    expected = [
+        'tiny/block1/unit_1/bottleneck_v2/shortcut',
+        'tiny/block1/unit_1/bottleneck_v2/conv1',
+        'tiny/block1/unit_1/bottleneck_v2/conv2',
+        'tiny/block1/unit_1/bottleneck_v2/conv3',
+        'tiny/block1/unit_2/bottleneck_v2/conv1',
+        'tiny/block1/unit_2/bottleneck_v2/conv2',
+        'tiny/block1/unit_2/bottleneck_v2/conv3',
+        'tiny/block2/unit_1/bottleneck_v2/shortcut',
+        'tiny/block2/unit_1/bottleneck_v2/conv1',
+        'tiny/block2/unit_1/bottleneck_v2/conv2',
+        'tiny/block2/unit_1/bottleneck_v2/conv3',
+        'tiny/block2/unit_2/bottleneck_v2/conv1',
+        'tiny/block2/unit_2/bottleneck_v2/conv2',
+        'tiny/block2/unit_2/bottleneck_v2/conv3']
+    self.assertItemsEqual(expected, end_points)
+
+  def _stack_blocks_nondense(self, net, blocks):
+    """A simplified ResNet Block stacker without output stride control."""
+    for block in blocks:
+      with tf.variable_scope(block.scope, 'block', [net]):
+        for i, unit in enumerate(block.args):
+          with tf.variable_scope('unit_%d' % (i + 1), values=[net]):
+            net = block.unit_fn(net, rate=1, **unit)
+    return net
+
+  def testAtrousValuesBottleneck(self):
+    """Verify the values of dense feature extraction by atrous convolution.
+
+    Make sure that dense feature extraction by stack_blocks_dense() followed by
+    subsampling gives identical results to feature extraction at the nominal
+    network output stride using the simple self._stack_blocks_nondense() above.
+    """
+    block = resnet_v2.resnet_v2_block
+    blocks = [
+        block('block1', base_depth=1, num_units=2, stride=2),
+        block('block2', base_depth=2, num_units=2, stride=2),
+        block('block3', base_depth=4, num_units=2, stride=2),
+        block('block4', base_depth=8, num_units=2, stride=1),
+    ]
+    nominal_stride = 8
+
+    # Test both odd and even input dimensions.
+    height = 30
+    width = 31
+    with slim.arg_scope(resnet_utils.resnet_arg_scope()):
+      with slim.arg_scope([slim.batch_norm], is_training=False):
+        for output_stride in [1, 2, 4, 8, None]:
+          with tf.Graph().as_default():
+            with self.test_session() as sess:
+              tf.set_random_seed(0)
+              inputs = create_test_input(1, height, width, 3)
+              # Dense feature extraction followed by subsampling.
+              output = resnet_utils.stack_blocks_dense(inputs,
+                                                       blocks,
+                                                       output_stride)
+              if output_stride is None:
+                factor = 1
+              else:
+                factor = nominal_stride // output_stride
+
+              output = resnet_utils.subsample(output, factor)
+              # Make the two networks use the same weights.
+              tf.get_variable_scope().reuse_variables()
+              # Feature extraction at the nominal network rate.
+              expected = self._stack_blocks_nondense(inputs, blocks)
+              sess.run(tf.global_variables_initializer())
+              output, expected = sess.run([output, expected])
+              self.assertAllClose(output, expected, atol=1e-4, rtol=1e-4)
+
+
+class ResnetCompleteNetworkTest(tf.test.TestCase):
+  """Tests with complete small ResNet v2 networks."""
+
+  def _resnet_small(self,
+                    inputs,
+                    num_classes=None,
+                    is_training=True,
+                    global_pool=True,
+                    output_stride=None,
+                    include_root_block=True,
+                    reuse=None,
+                    scope='resnet_v2_small'):
+    """A shallow and thin ResNet v2 for faster tests."""
+    block = resnet_v2.resnet_v2_block
+    blocks = [
+        block('block1', base_depth=1, num_units=3, stride=2),
+        block('block2', base_depth=2, num_units=3, stride=2),
+        block('block3', base_depth=4, num_units=3, stride=2),
+        block('block4', base_depth=8, num_units=2, stride=1),
+    ]
+    return resnet_v2.resnet_v2(inputs, blocks, num_classes,
+                               is_training=is_training,
+                               global_pool=global_pool,
+                               output_stride=output_stride,
+                               include_root_block=include_root_block,
+                               reuse=reuse,
+                               scope=scope)
+
+  def testClassificationEndPoints(self):
+    global_pool = True
+    num_classes = 10
+    inputs = create_test_input(2, 224, 224, 3)
+    with slim.arg_scope(resnet_utils.resnet_arg_scope()):
+      logits, end_points = self._resnet_small(inputs, num_classes,
+                                              global_pool=global_pool,
+                                              scope='resnet')
+    self.assertTrue(logits.op.name.startswith('resnet/logits'))
+    self.assertListEqual(logits.get_shape().as_list(), [2, 1, 1, num_classes])
+    self.assertTrue('predictions' in end_points)
+    self.assertListEqual(end_points['predictions'].get_shape().as_list(),
+                         [2, 1, 1, num_classes])
+
+  def testClassificationShapes(self):
+    global_pool = True
+    num_classes = 10
+    inputs = create_test_input(2, 224, 224, 3)
+    with slim.arg_scope(resnet_utils.resnet_arg_scope()):
+      _, end_points = self._resnet_small(inputs, num_classes,
+                                         global_pool=global_pool,
+                                         scope='resnet')
+      endpoint_to_shape = {
+          'resnet/block1': [2, 28, 28, 4],
+          'resnet/block2': [2, 14, 14, 8],
+          'resnet/block3': [2, 7, 7, 16],
+          'resnet/block4': [2, 7, 7, 32]}
+      for endpoint in endpoint_to_shape:
+        shape = endpoint_to_shape[endpoint]
+        self.assertListEqual(end_points[endpoint].get_shape().as_list(), shape)
+
+  def testFullyConvolutionalEndpointShapes(self):
+    global_pool = False
+    num_classes = 10
+    inputs = create_test_input(2, 321, 321, 3)
+    with slim.arg_scope(resnet_utils.resnet_arg_scope()):
+      _, end_points = self._resnet_small(inputs, num_classes,
+                                         global_pool=global_pool,
+                                         scope='resnet')
+      endpoint_to_shape = {
+          'resnet/block1': [2, 41, 41, 4],
+          'resnet/block2': [2, 21, 21, 8],
+          'resnet/block3': [2, 11, 11, 16],
+          'resnet/block4': [2, 11, 11, 32]}
+      for endpoint in endpoint_to_shape:
+        shape = endpoint_to_shape[endpoint]
+        self.assertListEqual(end_points[endpoint].get_shape().as_list(), shape)
+
+  def testRootlessFullyConvolutionalEndpointShapes(self):
+    global_pool = False
+    num_classes = 10
+    inputs = create_test_input(2, 128, 128, 3)
+    with slim.arg_scope(resnet_utils.resnet_arg_scope()):
+      _, end_points = self._resnet_small(inputs, num_classes,
+                                         global_pool=global_pool,
+                                         include_root_block=False,
+                                         scope='resnet')
+      endpoint_to_shape = {
+          'resnet/block1': [2, 64, 64, 4],
+          'resnet/block2': [2, 32, 32, 8],
+          'resnet/block3': [2, 16, 16, 16],
+          'resnet/block4': [2, 16, 16, 32]}
+      for endpoint in endpoint_to_shape:
+        shape = endpoint_to_shape[endpoint]
+        self.assertListEqual(end_points[endpoint].get_shape().as_list(), shape)
+
+  def testAtrousFullyConvolutionalEndpointShapes(self):
+    global_pool = False
+    num_classes = 10
+    output_stride = 8
+    inputs = create_test_input(2, 321, 321, 3)
+    with slim.arg_scope(resnet_utils.resnet_arg_scope()):
+      _, end_points = self._resnet_small(inputs,
+                                         num_classes,
+                                         global_pool=global_pool,
+                                         output_stride=output_stride,
+                                         scope='resnet')
+      endpoint_to_shape = {
+          'resnet/block1': [2, 41, 41, 4],
+          'resnet/block2': [2, 41, 41, 8],
+          'resnet/block3': [2, 41, 41, 16],
+          'resnet/block4': [2, 41, 41, 32]}
+      for endpoint in endpoint_to_shape:
+        shape = endpoint_to_shape[endpoint]
+        self.assertListEqual(end_points[endpoint].get_shape().as_list(), shape)
+
+  def testAtrousFullyConvolutionalValues(self):
+    """Verify dense feature extraction with atrous convolution."""
+    nominal_stride = 32
+    for output_stride in [4, 8, 16, 32, None]:
+      with slim.arg_scope(resnet_utils.resnet_arg_scope()):
+        with tf.Graph().as_default():
+          with self.test_session() as sess:
+            tf.set_random_seed(0)
+            inputs = create_test_input(2, 81, 81, 3)
+            # Dense feature extraction followed by subsampling.
+            output, _ = self._resnet_small(inputs, None,
+                                           is_training=False,
+                                           global_pool=False,
+                                           output_stride=output_stride)
+            if output_stride is None:
+              factor = 1
+            else:
+              factor = nominal_stride // output_stride
+            output = resnet_utils.subsample(output, factor)
+            # Make the two networks use the same weights.
+            tf.get_variable_scope().reuse_variables()
+            # Feature extraction at the nominal network rate.
+            expected, _ = self._resnet_small(inputs, None,
+                                             is_training=False,
+                                             global_pool=False)
+            sess.run(tf.global_variables_initializer())
+            self.assertAllClose(output.eval(), expected.eval(),
+                                atol=1e-4, rtol=1e-4)
+
+  def testUnknownBatchSize(self):
+    batch = 2
+    height, width = 65, 65
+    global_pool = True
+    num_classes = 10
+    inputs = create_test_input(None, height, width, 3)
+    with slim.arg_scope(resnet_utils.resnet_arg_scope()):
+      logits, _ = self._resnet_small(inputs, num_classes,
+                                     global_pool=global_pool,
+                                     scope='resnet')
+    self.assertTrue(logits.op.name.startswith('resnet/logits'))
+    self.assertListEqual(logits.get_shape().as_list(),
+                         [None, 1, 1, num_classes])
+    images = create_test_input(batch, height, width, 3)
+    with self.test_session() as sess:
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(logits, {inputs: images.eval()})
+      self.assertEqual(output.shape, (batch, 1, 1, num_classes))
+
+  def testFullyConvolutionalUnknownHeightWidth(self):
+    batch = 2
+    height, width = 65, 65
+    global_pool = False
+    inputs = create_test_input(batch, None, None, 3)
+    with slim.arg_scope(resnet_utils.resnet_arg_scope()):
+      output, _ = self._resnet_small(inputs, None,
+                                     global_pool=global_pool)
+    self.assertListEqual(output.get_shape().as_list(),
+                         [batch, None, None, 32])
+    images = create_test_input(batch, height, width, 3)
+    with self.test_session() as sess:
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(output, {inputs: images.eval()})
+      self.assertEqual(output.shape, (batch, 3, 3, 32))
+
+  def testAtrousFullyConvolutionalUnknownHeightWidth(self):
+    batch = 2
+    height, width = 65, 65
+    global_pool = False
+    output_stride = 8
+    inputs = create_test_input(batch, None, None, 3)
+    with slim.arg_scope(resnet_utils.resnet_arg_scope()):
+      output, _ = self._resnet_small(inputs,
+                                     None,
+                                     global_pool=global_pool,
+                                     output_stride=output_stride)
+    self.assertListEqual(output.get_shape().as_list(),
+                         [batch, None, None, 32])
+    images = create_test_input(batch, height, width, 3)
+    with self.test_session() as sess:
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(output, {inputs: images.eval()})
+      self.assertEqual(output.shape, (batch, 9, 9, 32))
+
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/vgg.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/vgg.py
new file mode 100755
index 0000000..4c74c5a
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/vgg.py
@@ -0,0 +1,265 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Contains model definitions for versions of the Oxford VGG network.
+
+These model definitions were introduced in the following technical report:
+
+  Very Deep Convolutional Networks For Large-Scale Image Recognition
+  Karen Simonyan and Andrew Zisserman
+  arXiv technical report, 2015
+  PDF: http://arxiv.org/pdf/1409.1556.pdf
+  ILSVRC 2014 Slides: http://www.robots.ox.ac.uk/~karen/pdf/ILSVRC_2014.pdf
+  CC-BY-4.0
+
+More information can be obtained from the VGG website:
+www.robots.ox.ac.uk/~vgg/research/very_deep/
+
+Usage:
+  with slim.arg_scope(vgg.vgg_arg_scope()):
+    outputs, end_points = vgg.vgg_a(inputs)
+
+  with slim.arg_scope(vgg.vgg_arg_scope()):
+    outputs, end_points = vgg.vgg_16(inputs)
+
+@@vgg_a
+@@vgg_16
+@@vgg_19
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf
+
+slim = tf.contrib.slim
+
+
+def vgg_arg_scope(weight_decay=0.0005):
+  """Defines the VGG arg scope.
+
+  Args:
+    weight_decay: The l2 regularization coefficient.
+
+  Returns:
+    An arg_scope.
+  """
+  with slim.arg_scope([slim.conv2d, slim.fully_connected],
+                      activation_fn=tf.nn.relu,
+                      weights_regularizer=slim.l2_regularizer(weight_decay),
+                      biases_initializer=tf.zeros_initializer()):
+    with slim.arg_scope([slim.conv2d], padding='SAME') as arg_sc:
+      return arg_sc
+
+
+def vgg_a(inputs,
+          num_classes=1000,
+          is_training=True,
+          dropout_keep_prob=0.5,
+          spatial_squeeze=True,
+          scope='vgg_a',
+          fc_conv_padding='VALID'):
+  """Oxford Net VGG 11-Layers version A Example.
+
+  Note: All the fully_connected layers have been transformed to conv2d layers.
+        To use in classification mode, resize input to 224x224.
+
+  Args:
+    inputs: a tensor of size [batch_size, height, width, channels].
+    num_classes: number of predicted classes.
+    is_training: whether or not the model is being trained.
+    dropout_keep_prob: the probability that activations are kept in the dropout
+      layers during training.
+    spatial_squeeze: whether or not should squeeze the spatial dimensions of the
+      outputs. Useful to remove unnecessary dimensions for classification.
+    scope: Optional scope for the variables.
+    fc_conv_padding: the type of padding to use for the fully connected layer
+      that is implemented as a convolutional layer. Use 'SAME' padding if you
+      are applying the network in a fully convolutional manner and want to
+      get a prediction map downsampled by a factor of 32 as an output. Otherwise,
+      the output prediction map will be (input / 32) - 6 in case of 'VALID' padding.
+
+  Returns:
+    the last op containing the log predictions and end_points dict.
+  """
+  with tf.variable_scope(scope, 'vgg_a', [inputs]) as sc:
+    end_points_collection = sc.name + '_end_points'
+    # Collect outputs for conv2d, fully_connected and max_pool2d.
+    with slim.arg_scope([slim.conv2d, slim.max_pool2d],
+                        outputs_collections=end_points_collection):
+      net = slim.repeat(inputs, 1, slim.conv2d, 64, [3, 3], scope='conv1')
+      net = slim.max_pool2d(net, [2, 2], scope='pool1')
+      net = slim.repeat(net, 1, slim.conv2d, 128, [3, 3], scope='conv2')
+      net = slim.max_pool2d(net, [2, 2], scope='pool2')
+      net = slim.repeat(net, 2, slim.conv2d, 256, [3, 3], scope='conv3')
+      net = slim.max_pool2d(net, [2, 2], scope='pool3')
+      net = slim.repeat(net, 2, slim.conv2d, 512, [3, 3], scope='conv4')
+      net = slim.max_pool2d(net, [2, 2], scope='pool4')
+      net = slim.repeat(net, 2, slim.conv2d, 512, [3, 3], scope='conv5')
+      net = slim.max_pool2d(net, [2, 2], scope='pool5')
+      # Use conv2d instead of fully_connected layers.
+      net = slim.conv2d(net, 4096, [7, 7], padding=fc_conv_padding, scope='fc6')
+      net = slim.dropout(net, dropout_keep_prob, is_training=is_training,
+                         scope='dropout6')
+      net = slim.conv2d(net, 4096, [1, 1], scope='fc7')
+      net = slim.dropout(net, dropout_keep_prob, is_training=is_training,
+                         scope='dropout7')
+      net = slim.conv2d(net, num_classes, [1, 1],
+                        activation_fn=None,
+                        normalizer_fn=None,
+                        scope='fc8')
+      # Convert end_points_collection into a end_point dict.
+      end_points = slim.utils.convert_collection_to_dict(end_points_collection)
+      if spatial_squeeze:
+        net = tf.squeeze(net, [1, 2], name='fc8/squeezed')
+        end_points[sc.name + '/fc8'] = net
+      return net, end_points
+vgg_a.default_image_size = 224
+
+
+def vgg_16(inputs,
+           num_classes=1000,
+           is_training=True,
+           dropout_keep_prob=0.5,
+           spatial_squeeze=True,
+           scope='vgg_16',
+           fc_conv_padding='VALID'):
+  """Oxford Net VGG 16-Layers version D Example.
+
+  Note: All the fully_connected layers have been transformed to conv2d layers.
+        To use in classification mode, resize input to 224x224.
+
+  Args:
+    inputs: a tensor of size [batch_size, height, width, channels].
+    num_classes: number of predicted classes.
+    is_training: whether or not the model is being trained.
+    dropout_keep_prob: the probability that activations are kept in the dropout
+      layers during training.
+    spatial_squeeze: whether or not should squeeze the spatial dimensions of the
+      outputs. Useful to remove unnecessary dimensions for classification.
+    scope: Optional scope for the variables.
+    fc_conv_padding: the type of padding to use for the fully connected layer
+      that is implemented as a convolutional layer. Use 'SAME' padding if you
+      are applying the network in a fully convolutional manner and want to
+      get a prediction map downsampled by a factor of 32 as an output. Otherwise,
+      the output prediction map will be (input / 32) - 6 in case of 'VALID' padding.
+
+  Returns:
+    the last op containing the log predictions and end_points dict.
+  """
+  with tf.variable_scope(scope, 'vgg_16', [inputs]) as sc:
+    end_points_collection = sc.name + '_end_points'
+    # Collect outputs for conv2d, fully_connected and max_pool2d.
+    with slim.arg_scope([slim.conv2d, slim.fully_connected, slim.max_pool2d],
+                        outputs_collections=end_points_collection):
+      net = slim.repeat(inputs, 2, slim.conv2d, 64, [3, 3], scope='conv1')
+      net = slim.max_pool2d(net, [2, 2], scope='pool1')
+      net = slim.repeat(net, 2, slim.conv2d, 128, [3, 3], scope='conv2')
+      net = slim.max_pool2d(net, [2, 2], scope='pool2')
+      net = slim.repeat(net, 3, slim.conv2d, 256, [3, 3], scope='conv3')
+      net = slim.max_pool2d(net, [2, 2], scope='pool3')
+      net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv4')
+      net = slim.max_pool2d(net, [2, 2], scope='pool4')
+      net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv5')
+      net = slim.max_pool2d(net, [2, 2], scope='pool5')
+      # Use conv2d instead of fully_connected layers.
+      net = slim.conv2d(net, 4096, [7, 7], padding=fc_conv_padding, scope='fc6')
+      net = slim.dropout(net, dropout_keep_prob, is_training=is_training,
+                         scope='dropout6')
+      net = slim.conv2d(net, 4096, [1, 1], scope='fc7')
+      net = slim.dropout(net, dropout_keep_prob, is_training=is_training,
+                         scope='dropout7')
+      # yjr_feature = tf.squeeze(net)
+      net = slim.conv2d(net, num_classes, [1, 1],
+                        activation_fn=None,
+                        normalizer_fn=None,
+                        scope='fc8')
+      # Convert end_points_collection into a end_point dict.
+      end_points = slim.utils.convert_collection_to_dict(end_points_collection)
+      if spatial_squeeze:
+        net = tf.squeeze(net, [1, 2], name='fc8/squeezed')
+        end_points[sc.name + '/fc8'] = net
+      # end_points['yjr_feature'] = yjr_feature
+      end_points['predictions'] = slim.softmax(net, scope='predictions')
+      return net, end_points
+vgg_16.default_image_size = 224
+
+
+def vgg_19(inputs,
+           num_classes=1000,
+           is_training=True,
+           dropout_keep_prob=0.5,
+           spatial_squeeze=True,
+           scope='vgg_19',
+           fc_conv_padding='VALID'):
+  """Oxford Net VGG 19-Layers version E Example.
+
+  Note: All the fully_connected layers have been transformed to conv2d layers.
+        To use in classification mode, resize input to 224x224.
+
+  Args:
+    inputs: a tensor of size [batch_size, height, width, channels].
+    num_classes: number of predicted classes.
+    is_training: whether or not the model is being trained.
+    dropout_keep_prob: the probability that activations are kept in the dropout
+      layers during training.
+    spatial_squeeze: whether or not should squeeze the spatial dimensions of the
+      outputs. Useful to remove unnecessary dimensions for classification.
+    scope: Optional scope for the variables.
+    fc_conv_padding: the type of padding to use for the fully connected layer
+      that is implemented as a convolutional layer. Use 'SAME' padding if you
+      are applying the network in a fully convolutional manner and want to
+      get a prediction map downsampled by a factor of 32 as an output. Otherwise,
+      the output prediction map will be (input / 32) - 6 in case of 'VALID' padding.
+
+  Returns:
+    the last op containing the log predictions and end_points dict.
+  """
+  with tf.variable_scope(scope, 'vgg_19', [inputs]) as sc:
+    end_points_collection = sc.name + '_end_points'
+    # Collect outputs for conv2d, fully_connected and max_pool2d.
+    with slim.arg_scope([slim.conv2d, slim.fully_connected, slim.max_pool2d],
+                        outputs_collections=end_points_collection):
+      net = slim.repeat(inputs, 2, slim.conv2d, 64, [3, 3], scope='conv1')
+      net = slim.max_pool2d(net, [2, 2], scope='pool1')
+      net = slim.repeat(net, 2, slim.conv2d, 128, [3, 3], scope='conv2')
+      net = slim.max_pool2d(net, [2, 2], scope='pool2')
+      net = slim.repeat(net, 4, slim.conv2d, 256, [3, 3], scope='conv3')
+      net = slim.max_pool2d(net, [2, 2], scope='pool3')
+      net = slim.repeat(net, 4, slim.conv2d, 512, [3, 3], scope='conv4')
+      net = slim.max_pool2d(net, [2, 2], scope='pool4')
+      net = slim.repeat(net, 4, slim.conv2d, 512, [3, 3], scope='conv5')
+      net = slim.max_pool2d(net, [2, 2], scope='pool5')
+      # Use conv2d instead of fully_connected layers.
+      net = slim.conv2d(net, 4096, [7, 7], padding=fc_conv_padding, scope='fc6')
+      net = slim.dropout(net, dropout_keep_prob, is_training=is_training,
+                         scope='dropout6')
+      net = slim.conv2d(net, 4096, [1, 1], scope='fc7')
+      net = slim.dropout(net, dropout_keep_prob, is_training=is_training,
+                         scope='dropout7')
+      net = slim.conv2d(net, num_classes, [1, 1],
+                        activation_fn=None,
+                        normalizer_fn=None,
+                        scope='fc8')
+      # Convert end_points_collection into a end_point dict.
+      end_points = slim.utils.convert_collection_to_dict(end_points_collection)
+      if spatial_squeeze:
+        net = tf.squeeze(net, [1, 2], name='fc8/squeezed')
+        end_points[sc.name + '/fc8'] = net
+      return net, end_points
+vgg_19.default_image_size = 224
+
+# Alias
+vgg_d = vgg_16
+vgg_e = vgg_19
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/vgg_test.py b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/vgg_test.py
new file mode 100755
index 0000000..8e383b3
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/slim_nets/vgg_test.py
@@ -0,0 +1,455 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for slim.slim_nets.vgg."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf
+
+from nets import vgg
+
+slim = tf.contrib.slim
+
+
+class VGGATest(tf.test.TestCase):
+
+  def testBuild(self):
+    batch_size = 5
+    height, width = 224, 224
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, _ = vgg.vgg_a(inputs, num_classes)
+      self.assertEquals(logits.op.name, 'vgg_a/fc8/squeezed')
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [batch_size, num_classes])
+
+  def testFullyConvolutional(self):
+    batch_size = 1
+    height, width = 256, 256
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, _ = vgg.vgg_a(inputs, num_classes, spatial_squeeze=False)
+      self.assertEquals(logits.op.name, 'vgg_a/fc8/BiasAdd')
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [batch_size, 2, 2, num_classes])
+
+  def testEndPoints(self):
+    batch_size = 5
+    height, width = 224, 224
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      _, end_points = vgg.vgg_a(inputs, num_classes)
+      expected_names = ['vgg_a/conv1/conv1_1',
+                        'vgg_a/pool1',
+                        'vgg_a/conv2/conv2_1',
+                        'vgg_a/pool2',
+                        'vgg_a/conv3/conv3_1',
+                        'vgg_a/conv3/conv3_2',
+                        'vgg_a/pool3',
+                        'vgg_a/conv4/conv4_1',
+                        'vgg_a/conv4/conv4_2',
+                        'vgg_a/pool4',
+                        'vgg_a/conv5/conv5_1',
+                        'vgg_a/conv5/conv5_2',
+                        'vgg_a/pool5',
+                        'vgg_a/fc6',
+                        'vgg_a/fc7',
+                        'vgg_a/fc8'
+                       ]
+      self.assertSetEqual(set(end_points.keys()), set(expected_names))
+
+  def testModelVariables(self):
+    batch_size = 5
+    height, width = 224, 224
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      vgg.vgg_a(inputs, num_classes)
+      expected_names = ['vgg_a/conv1/conv1_1/weights',
+                        'vgg_a/conv1/conv1_1/biases',
+                        'vgg_a/conv2/conv2_1/weights',
+                        'vgg_a/conv2/conv2_1/biases',
+                        'vgg_a/conv3/conv3_1/weights',
+                        'vgg_a/conv3/conv3_1/biases',
+                        'vgg_a/conv3/conv3_2/weights',
+                        'vgg_a/conv3/conv3_2/biases',
+                        'vgg_a/conv4/conv4_1/weights',
+                        'vgg_a/conv4/conv4_1/biases',
+                        'vgg_a/conv4/conv4_2/weights',
+                        'vgg_a/conv4/conv4_2/biases',
+                        'vgg_a/conv5/conv5_1/weights',
+                        'vgg_a/conv5/conv5_1/biases',
+                        'vgg_a/conv5/conv5_2/weights',
+                        'vgg_a/conv5/conv5_2/biases',
+                        'vgg_a/fc6/weights',
+                        'vgg_a/fc6/biases',
+                        'vgg_a/fc7/weights',
+                        'vgg_a/fc7/biases',
+                        'vgg_a/fc8/weights',
+                        'vgg_a/fc8/biases',
+                       ]
+      model_variables = [v.op.name for v in slim.get_model_variables()]
+      self.assertSetEqual(set(model_variables), set(expected_names))
+
+  def testEvaluation(self):
+    batch_size = 2
+    height, width = 224, 224
+    num_classes = 1000
+    with self.test_session():
+      eval_inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, _ = vgg.vgg_a(eval_inputs, is_training=False)
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [batch_size, num_classes])
+      predictions = tf.argmax(logits, 1)
+      self.assertListEqual(predictions.get_shape().as_list(), [batch_size])
+
+  def testTrainEvalWithReuse(self):
+    train_batch_size = 2
+    eval_batch_size = 1
+    train_height, train_width = 224, 224
+    eval_height, eval_width = 256, 256
+    num_classes = 1000
+    with self.test_session():
+      train_inputs = tf.random_uniform(
+          (train_batch_size, train_height, train_width, 3))
+      logits, _ = vgg.vgg_a(train_inputs)
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [train_batch_size, num_classes])
+      tf.get_variable_scope().reuse_variables()
+      eval_inputs = tf.random_uniform(
+          (eval_batch_size, eval_height, eval_width, 3))
+      logits, _ = vgg.vgg_a(eval_inputs, is_training=False,
+                            spatial_squeeze=False)
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [eval_batch_size, 2, 2, num_classes])
+      logits = tf.reduce_mean(logits, [1, 2])
+      predictions = tf.argmax(logits, 1)
+      self.assertEquals(predictions.get_shape().as_list(), [eval_batch_size])
+
+  def testForward(self):
+    batch_size = 1
+    height, width = 224, 224
+    with self.test_session() as sess:
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, _ = vgg.vgg_a(inputs)
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(logits)
+      self.assertTrue(output.any())
+
+
+class VGG16Test(tf.test.TestCase):
+
+  def testBuild(self):
+    batch_size = 5
+    height, width = 224, 224
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, _ = vgg.vgg_16(inputs, num_classes)
+      self.assertEquals(logits.op.name, 'vgg_16/fc8/squeezed')
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [batch_size, num_classes])
+
+  def testFullyConvolutional(self):
+    batch_size = 1
+    height, width = 256, 256
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, _ = vgg.vgg_16(inputs, num_classes, spatial_squeeze=False)
+      self.assertEquals(logits.op.name, 'vgg_16/fc8/BiasAdd')
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [batch_size, 2, 2, num_classes])
+
+  def testEndPoints(self):
+    batch_size = 5
+    height, width = 224, 224
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      _, end_points = vgg.vgg_16(inputs, num_classes)
+      expected_names = ['vgg_16/conv1/conv1_1',
+                        'vgg_16/conv1/conv1_2',
+                        'vgg_16/pool1',
+                        'vgg_16/conv2/conv2_1',
+                        'vgg_16/conv2/conv2_2',
+                        'vgg_16/pool2',
+                        'vgg_16/conv3/conv3_1',
+                        'vgg_16/conv3/conv3_2',
+                        'vgg_16/conv3/conv3_3',
+                        'vgg_16/pool3',
+                        'vgg_16/conv4/conv4_1',
+                        'vgg_16/conv4/conv4_2',
+                        'vgg_16/conv4/conv4_3',
+                        'vgg_16/pool4',
+                        'vgg_16/conv5/conv5_1',
+                        'vgg_16/conv5/conv5_2',
+                        'vgg_16/conv5/conv5_3',
+                        'vgg_16/pool5',
+                        'vgg_16/fc6',
+                        'vgg_16/fc7',
+                        'vgg_16/fc8'
+                       ]
+      self.assertSetEqual(set(end_points.keys()), set(expected_names))
+
+  def testModelVariables(self):
+    batch_size = 5
+    height, width = 224, 224
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      vgg.vgg_16(inputs, num_classes)
+      expected_names = ['vgg_16/conv1/conv1_1/weights',
+                        'vgg_16/conv1/conv1_1/biases',
+                        'vgg_16/conv1/conv1_2/weights',
+                        'vgg_16/conv1/conv1_2/biases',
+                        'vgg_16/conv2/conv2_1/weights',
+                        'vgg_16/conv2/conv2_1/biases',
+                        'vgg_16/conv2/conv2_2/weights',
+                        'vgg_16/conv2/conv2_2/biases',
+                        'vgg_16/conv3/conv3_1/weights',
+                        'vgg_16/conv3/conv3_1/biases',
+                        'vgg_16/conv3/conv3_2/weights',
+                        'vgg_16/conv3/conv3_2/biases',
+                        'vgg_16/conv3/conv3_3/weights',
+                        'vgg_16/conv3/conv3_3/biases',
+                        'vgg_16/conv4/conv4_1/weights',
+                        'vgg_16/conv4/conv4_1/biases',
+                        'vgg_16/conv4/conv4_2/weights',
+                        'vgg_16/conv4/conv4_2/biases',
+                        'vgg_16/conv4/conv4_3/weights',
+                        'vgg_16/conv4/conv4_3/biases',
+                        'vgg_16/conv5/conv5_1/weights',
+                        'vgg_16/conv5/conv5_1/biases',
+                        'vgg_16/conv5/conv5_2/weights',
+                        'vgg_16/conv5/conv5_2/biases',
+                        'vgg_16/conv5/conv5_3/weights',
+                        'vgg_16/conv5/conv5_3/biases',
+                        'vgg_16/fc6/weights',
+                        'vgg_16/fc6/biases',
+                        'vgg_16/fc7/weights',
+                        'vgg_16/fc7/biases',
+                        'vgg_16/fc8/weights',
+                        'vgg_16/fc8/biases',
+                       ]
+      model_variables = [v.op.name for v in slim.get_model_variables()]
+      self.assertSetEqual(set(model_variables), set(expected_names))
+
+  def testEvaluation(self):
+    batch_size = 2
+    height, width = 224, 224
+    num_classes = 1000
+    with self.test_session():
+      eval_inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, _ = vgg.vgg_16(eval_inputs, is_training=False)
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [batch_size, num_classes])
+      predictions = tf.argmax(logits, 1)
+      self.assertListEqual(predictions.get_shape().as_list(), [batch_size])
+
+  def testTrainEvalWithReuse(self):
+    train_batch_size = 2
+    eval_batch_size = 1
+    train_height, train_width = 224, 224
+    eval_height, eval_width = 256, 256
+    num_classes = 1000
+    with self.test_session():
+      train_inputs = tf.random_uniform(
+          (train_batch_size, train_height, train_width, 3))
+      logits, _ = vgg.vgg_16(train_inputs)
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [train_batch_size, num_classes])
+      tf.get_variable_scope().reuse_variables()
+      eval_inputs = tf.random_uniform(
+          (eval_batch_size, eval_height, eval_width, 3))
+      logits, _ = vgg.vgg_16(eval_inputs, is_training=False,
+                             spatial_squeeze=False)
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [eval_batch_size, 2, 2, num_classes])
+      logits = tf.reduce_mean(logits, [1, 2])
+      predictions = tf.argmax(logits, 1)
+      self.assertEquals(predictions.get_shape().as_list(), [eval_batch_size])
+
+  def testForward(self):
+    batch_size = 1
+    height, width = 224, 224
+    with self.test_session() as sess:
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, _ = vgg.vgg_16(inputs)
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(logits)
+      self.assertTrue(output.any())
+
+
+class VGG19Test(tf.test.TestCase):
+
+  def testBuild(self):
+    batch_size = 5
+    height, width = 224, 224
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, _ = vgg.vgg_19(inputs, num_classes)
+      self.assertEquals(logits.op.name, 'vgg_19/fc8/squeezed')
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [batch_size, num_classes])
+
+  def testFullyConvolutional(self):
+    batch_size = 1
+    height, width = 256, 256
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, _ = vgg.vgg_19(inputs, num_classes, spatial_squeeze=False)
+      self.assertEquals(logits.op.name, 'vgg_19/fc8/BiasAdd')
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [batch_size, 2, 2, num_classes])
+
+  def testEndPoints(self):
+    batch_size = 5
+    height, width = 224, 224
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      _, end_points = vgg.vgg_19(inputs, num_classes)
+      expected_names = [
+          'vgg_19/conv1/conv1_1',
+          'vgg_19/conv1/conv1_2',
+          'vgg_19/pool1',
+          'vgg_19/conv2/conv2_1',
+          'vgg_19/conv2/conv2_2',
+          'vgg_19/pool2',
+          'vgg_19/conv3/conv3_1',
+          'vgg_19/conv3/conv3_2',
+          'vgg_19/conv3/conv3_3',
+          'vgg_19/conv3/conv3_4',
+          'vgg_19/pool3',
+          'vgg_19/conv4/conv4_1',
+          'vgg_19/conv4/conv4_2',
+          'vgg_19/conv4/conv4_3',
+          'vgg_19/conv4/conv4_4',
+          'vgg_19/pool4',
+          'vgg_19/conv5/conv5_1',
+          'vgg_19/conv5/conv5_2',
+          'vgg_19/conv5/conv5_3',
+          'vgg_19/conv5/conv5_4',
+          'vgg_19/pool5',
+          'vgg_19/fc6',
+          'vgg_19/fc7',
+          'vgg_19/fc8'
+      ]
+      self.assertSetEqual(set(end_points.keys()), set(expected_names))
+
+  def testModelVariables(self):
+    batch_size = 5
+    height, width = 224, 224
+    num_classes = 1000
+    with self.test_session():
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      vgg.vgg_19(inputs, num_classes)
+      expected_names = [
+          'vgg_19/conv1/conv1_1/weights',
+          'vgg_19/conv1/conv1_1/biases',
+          'vgg_19/conv1/conv1_2/weights',
+          'vgg_19/conv1/conv1_2/biases',
+          'vgg_19/conv2/conv2_1/weights',
+          'vgg_19/conv2/conv2_1/biases',
+          'vgg_19/conv2/conv2_2/weights',
+          'vgg_19/conv2/conv2_2/biases',
+          'vgg_19/conv3/conv3_1/weights',
+          'vgg_19/conv3/conv3_1/biases',
+          'vgg_19/conv3/conv3_2/weights',
+          'vgg_19/conv3/conv3_2/biases',
+          'vgg_19/conv3/conv3_3/weights',
+          'vgg_19/conv3/conv3_3/biases',
+          'vgg_19/conv3/conv3_4/weights',
+          'vgg_19/conv3/conv3_4/biases',
+          'vgg_19/conv4/conv4_1/weights',
+          'vgg_19/conv4/conv4_1/biases',
+          'vgg_19/conv4/conv4_2/weights',
+          'vgg_19/conv4/conv4_2/biases',
+          'vgg_19/conv4/conv4_3/weights',
+          'vgg_19/conv4/conv4_3/biases',
+          'vgg_19/conv4/conv4_4/weights',
+          'vgg_19/conv4/conv4_4/biases',
+          'vgg_19/conv5/conv5_1/weights',
+          'vgg_19/conv5/conv5_1/biases',
+          'vgg_19/conv5/conv5_2/weights',
+          'vgg_19/conv5/conv5_2/biases',
+          'vgg_19/conv5/conv5_3/weights',
+          'vgg_19/conv5/conv5_3/biases',
+          'vgg_19/conv5/conv5_4/weights',
+          'vgg_19/conv5/conv5_4/biases',
+          'vgg_19/fc6/weights',
+          'vgg_19/fc6/biases',
+          'vgg_19/fc7/weights',
+          'vgg_19/fc7/biases',
+          'vgg_19/fc8/weights',
+          'vgg_19/fc8/biases',
+      ]
+      model_variables = [v.op.name for v in slim.get_model_variables()]
+      self.assertSetEqual(set(model_variables), set(expected_names))
+
+  def testEvaluation(self):
+    batch_size = 2
+    height, width = 224, 224
+    num_classes = 1000
+    with self.test_session():
+      eval_inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, _ = vgg.vgg_19(eval_inputs, is_training=False)
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [batch_size, num_classes])
+      predictions = tf.argmax(logits, 1)
+      self.assertListEqual(predictions.get_shape().as_list(), [batch_size])
+
+  def testTrainEvalWithReuse(self):
+    train_batch_size = 2
+    eval_batch_size = 1
+    train_height, train_width = 224, 224
+    eval_height, eval_width = 256, 256
+    num_classes = 1000
+    with self.test_session():
+      train_inputs = tf.random_uniform(
+          (train_batch_size, train_height, train_width, 3))
+      logits, _ = vgg.vgg_19(train_inputs)
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [train_batch_size, num_classes])
+      tf.get_variable_scope().reuse_variables()
+      eval_inputs = tf.random_uniform(
+          (eval_batch_size, eval_height, eval_width, 3))
+      logits, _ = vgg.vgg_19(eval_inputs, is_training=False,
+                             spatial_squeeze=False)
+      self.assertListEqual(logits.get_shape().as_list(),
+                           [eval_batch_size, 2, 2, num_classes])
+      logits = tf.reduce_mean(logits, [1, 2])
+      predictions = tf.argmax(logits, 1)
+      self.assertEquals(predictions.get_shape().as_list(), [eval_batch_size])
+
+  def testForward(self):
+    batch_size = 1
+    height, width = 224, 224
+    with self.test_session() as sess:
+      inputs = tf.random_uniform((batch_size, height, width, 3))
+      logits, _ = vgg.vgg_19(inputs)
+      sess.run(tf.global_variables_initializer())
+      output = sess.run(logits)
+      self.assertTrue(output.any())
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/example-apps/PDD/pcb-defect-detection/libs/networks/some_test.py b/example-apps/PDD/pcb-defect-detection/libs/networks/some_test.py
new file mode 100755
index 0000000..5c71438
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/networks/some_test.py
@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+
+import tensorflow.contrib.slim as slim
+import os
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+
+
+@slim.add_arg_scope
+def fn(a, c=100):
+
+    return a+c
+
+
+with slim.arg_scope([fn], a=2):
+    with slim.arg_scope([fn], a=1):
+
+        print(fn())
+
+
diff --git a/example-apps/PDD/pcb-defect-detection/libs/setup.py b/example-apps/PDD/pcb-defect-detection/libs/setup.py
new file mode 100755
index 0000000..e7e4b4e
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/setup.py
@@ -0,0 +1,225 @@
+# --------------------------------------------------------
+# Fast R-CNN
+# Copyright (c) 2015 Microsoft
+# Licensed under The MIT License [see LICENSE for details]
+# Written by Ross Girshick
+# --------------------------------------------------------
+
+import os
+from os.path import join as pjoin
+from setuptools import setup
+from distutils.extension import Extension
+from Cython.Distutils import build_ext
+import subprocess
+import numpy as np
+
+
+def find_in_path(name, path):
+    "Find a file in a search path"
+    # Adapted fom
+    # http://code.activestate.com/recipes/52224-find-a-file-given-a-search-path/
+    for dir in path.split(os.pathsep):
+        binpath = pjoin(dir, name)
+        if os.path.exists(binpath):
+            return os.path.abspath(binpath)
+    return None
+
+
+def locate_cuda():
+    """Locate the CUDA environment on the system
+
+    Returns a dict with keys 'home', 'nvcc', 'include', and 'lib64'
+    and values giving the absolute path to each directory.
+
+    Starts by looking for the CUDAHOME env variable. If not found, everything
+    is based on finding 'nvcc' in the PATH.
+    """
+
+    # first check if the CUDAHOME env variable is in use
+    if 'CUDAHOME' in os.environ:
+        home = os.environ['CUDAHOME']
+        nvcc = pjoin(home, 'bin', 'nvcc')
+    else:
+        # otherwise, search the PATH for NVCC
+        default_path = pjoin(os.sep, 'usr', 'local', 'cuda', 'bin')
+        nvcc = find_in_path('nvcc', os.environ['PATH'] + os.pathsep + default_path)
+        if nvcc is None:
+            raise EnvironmentError('The nvcc binary could not be '
+                'located in your $PATH. Either add it to your path, or set $CUDAHOME')
+        home = os.path.dirname(os.path.dirname(nvcc))
+
+    cudaconfig = {'home':home, 'nvcc':nvcc,
+                  'include': pjoin(home, 'include'),
+                  'lib64': pjoin(home, 'lib64')}
+    for k, v in cudaconfig.iteritems():
+        if not os.path.exists(v):
+            raise EnvironmentError('The CUDA %s path could not be located in %s' % (k, v))
+
+    return cudaconfig
+CUDA = locate_cuda()
+
+
+# Obtain the numpy include directory.  This logic works across numpy versions.
+try:
+    numpy_include = np.get_include()
+except AttributeError:
+    numpy_include = np.get_numpy_include()
+
+
+def customize_compiler_for_nvcc(self):
+    """inject deep into distutils to customize how the dispatch
+    to gcc/nvcc works.
+
+    If you subclass UnixCCompiler, it's not trivial to get your subclass
+    injected in, and still have the right customizations (i.e.
+    distutils.sysconfig.customize_compiler) run on it. So instead of going
+    the OO route, I have this. Note, it's kindof like a wierd functional
+    subclassing going on."""
+
+    # tell the compiler it can processes .cu
+    self.src_extensions.append('.cu')
+
+    # save references to the default compiler_so and _comple methods
+    default_compiler_so = self.compiler_so
+    super = self._compile
+
+    # now redefine the _compile method. This gets executed for each
+    # object but distutils doesn't have the ability to change compilers
+    # based on source extension: we add it.
+    def _compile(obj, src, ext, cc_args, extra_postargs, pp_opts):
+        if os.path.splitext(src)[1] == '.cu':
+            # use the cuda for .cu files
+            self.set_executable('compiler_so', CUDA['nvcc'])
+            # use only a subset of the extra_postargs, which are 1-1 translated
+            # from the extra_compile_args in the Extension class
+            postargs = extra_postargs['nvcc']
+        else:
+            postargs = extra_postargs['gcc']
+
+        super(obj, src, ext, cc_args, postargs, pp_opts)
+        # reset the default compiler_so, which we might have changed for cuda
+        self.compiler_so = default_compiler_so
+
+    # inject our redefined _compile method into the class
+    self._compile = _compile
+
+
+# run the customize_compiler
+class custom_build_ext(build_ext):
+    def build_extensions(self):
+        customize_compiler_for_nvcc(self.compiler)
+        build_ext.build_extensions(self)
+
+
+ext_modules = [
+    # Extension(
+    #     "utils.cython_bbox",
+    #     ["utils/bbox.pyx"],
+    #     extra_compile_args={'gcc': ["-Wno-cpp", "-Wno-unused-function"]},
+    #     include_dirs = [numpy_include]
+    # ),
+    # Extension(
+    #     "nms.cpu_nms",
+    #     ["nms/cpu_nms.pyx"],
+    #     extra_compile_args={'gcc': ["-Wno-cpp", "-Wno-unused-function"]},
+    #     include_dirs = [numpy_include]
+    # ),
+    #
+    # Extension(
+    #     "rotation.rotate_cython_nms",
+    #     ["rotation/rotate_cython_nms.pyx"],
+    #     extra_compile_args={'gcc': ["-Wno-cpp", "-Wno-unused-function"]},
+    #     include_dirs = [numpy_include]
+    # ),
+    #
+    # Extension(
+    #     "rotation.rotate_circle_nms",
+    #     ["rotation/rotate_circle_nms.pyx"],
+    #     extra_compile_args={'gcc': ["-Wno-cpp", "-Wno-unused-function"]},
+    #     include_dirs = [numpy_include]
+    # ),
+    #
+    # Extension('nms.gpu_nms',
+    #     ['nms/nms_kernel.cu', 'nms/gpu_nms.pyx'],
+    #     library_dirs=[CUDA['lib64']],
+    #     libraries=['cudart'],
+    #     language='c++',
+    #     runtime_library_dirs=[CUDA['lib64']],
+    #     # this syntax is specific to this build system
+    #     # we're only going to use certain compiler args with nvcc and not with
+    #     # gcc the implementation of this trick is in customize_compiler() below
+    #     extra_compile_args={'gcc': ["-Wno-unused-function"],
+    #                         'nvcc': ['-arch=sm_35',
+    #                                  '--ptxas-options=-v',
+    #                                  '-c',
+    #                                  '--compiler-options',
+    #                                  "'-fPIC'"]},
+    #     include_dirs = [numpy_include, CUDA['include']]
+    # ),
+    # Extension('rotation.rotate_gpu_nms',
+    #     ['rotation/rotate_nms_kernel.cu', 'rotation/rotate_gpu_nms.pyx'],
+    #     library_dirs=[CUDA['lib64']],
+    #     libraries=['cudart'],
+    #     language='c++',
+    #     runtime_library_dirs=[CUDA['lib64']],
+    #     # this syntax is specific to this build system
+    #     # we're only going to use certain compiler args with nvcc anrbd not with
+    #     # gcc the implementation of this trick is in customize_compiler() below
+    #     extra_compile_args={'gcc': ["-Wno-unused-function"],
+    #                         'nvcc': ['-arch=sm_35',
+    #                                  '--ptxas-options=-v',
+    #                                  '-c',
+    #                                  '--compiler-options',
+    #                                  "'-fPIC'"]},
+    #     include_dirs = [numpy_include, CUDA['include']]
+    # ),
+    Extension('rotation.rbbox_overlaps',
+        ['rotation/rbbox_overlaps_kernel.cu', 'rotation/rbbox_overlaps.pyx'],
+        library_dirs=[CUDA['lib64']],
+        libraries=['cudart'],
+        language='c++',
+        runtime_library_dirs=[CUDA['lib64']],
+        # this syntax is specific to this build system
+        # we're only going to use certain compiler args with nvcc and not with
+        # gcc the implementation of this trick is in customize_compiler() below
+        extra_compile_args={'gcc': ["-Wno-unused-function"],
+                            'nvcc': ['-arch=sm_35',
+                                     '--ptxas-options=-v',
+                                     '-c',
+                                     '--compiler-options',
+                                     "'-fPIC'"]},
+        include_dirs = [numpy_include, CUDA['include']]
+    ),
+    # Extension('rotation.rotate_polygon_nms',
+    #     ['rotation/rotate_polygon_nms_kernel.cu', 'rotation/rotate_polygon_nms.pyx'],
+    #     library_dirs=[CUDA['lib64']],
+    #     libraries=['cudart'],
+    #     language='c++',
+    #     runtime_library_dirs=[CUDA['lib64']],
+    #     # this syntax is specific to this build system
+    #     # we're only going to use certain compiler args with nvcc and not with
+    #     # gcc the implementation of this trick is in customize_compiler() below
+    #     extra_compile_args={'gcc': ["-Wno-unused-function"],
+    #                         'nvcc': ['-arch=sm_35',
+    #                                  '--ptxas-options=-v',
+    #                                  '-c',
+    #                                  '--compiler-options',
+    #                                  "'-fPIC'"]},
+    #     include_dirs = [numpy_include, CUDA['include']]
+    # ),
+    #
+    # Extension(
+    #     'pycocotools._mask',
+    #     sources=['pycocotools/maskApi.c', 'pycocotools/_mask.pyx'],
+    #     include_dirs = [numpy_include, 'pycocotools'],
+    #     extra_compile_args={
+    #         'gcc': ['-Wno-cpp', '-Wno-unused-function', '-std=c99']},
+    # ),
+]
+
+setup(
+    name='fast_rcnn',
+    ext_modules=ext_modules,
+    # inject our custom trigger
+    cmdclass={'build_ext': custom_build_ext},
+)
diff --git a/example-apps/PDD/pcb-defect-detection/libs/val_libs/__init__.py b/example-apps/PDD/pcb-defect-detection/libs/val_libs/__init__.py
new file mode 100755
index 0000000..e69de29
diff --git a/example-apps/PDD/pcb-defect-detection/libs/val_libs/voc_eval.py b/example-apps/PDD/pcb-defect-detection/libs/val_libs/voc_eval.py
new file mode 100755
index 0000000..fc2bde1
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/libs/val_libs/voc_eval.py
@@ -0,0 +1,274 @@
+# --------------------------------------------------------
+# Fast/er R-CNN
+# Licensed under The MIT License [see LICENSE for details]
+# Written by Bharath Hariharan
+# --------------------------------------------------------
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import xml.etree.ElementTree as ET
+import os
+import pickle
+import numpy as np
+
+import matplotlib.pyplot as plt
+import pylab as pl
+from sklearn.metrics import precision_recall_curve
+from itertools import cycle
+
+from libs.label_name_dict.label_dict import NAME_LABEL_MAP
+from libs.configs import cfgs
+from help_utils.tools import *
+
+def write_voc_results_file(all_boxes, test_imgid_list, det_save_dir):
+  '''
+
+  :param all_boxes: is a list. each item reprensent the detections of a img.
+  the detections is a array. shape is [-1, 6]. [category, score, xmin, ymin, xmax, ymax]
+  Note that: if none detections in this img. that the detetions is : []
+
+  :param test_imgid_list:
+  :param det_save_path:
+  :return:
+  '''
+  for cls, cls_id in NAME_LABEL_MAP.items():
+    if cls == 'back_ground':
+      continue
+    print("Writing {} VOC resutls file".format(cls))
+
+    mkdir(det_save_dir)
+    det_save_path = os.path.join(det_save_dir, "det_"+cls+".txt")
+    with open(det_save_path, 'wt') as f:
+      for index, img_name in enumerate(test_imgid_list):
+        this_img_detections = all_boxes[index]
+
+        this_cls_detections = this_img_detections[this_img_detections[:, 0]==cls_id]
+        if this_cls_detections.shape[0] == 0:
+          continue # this cls has none detections in this img
+        for a_det in this_cls_detections:
+          f.write('{:s} {:.3f} {:.1f} {:.1f} {:.1f} {:.1f}\n'.
+                  format(img_name, a_det[1],
+                         a_det[2], a_det[3],
+                         a_det[4], a_det[5]))  # that is [img_name, score, xmin, ymin, xmax, ymax]
+
+
+def parse_rec(filename):
+  """ Parse a PASCAL VOC xml file """
+  tree = ET.parse(filename)
+  objects = []
+  for obj in tree.findall('object'):
+    obj_struct = {}
+    obj_struct['name'] = obj.find('name').text
+    obj_struct['pose'] = obj.find('pose').text
+    obj_struct['truncated'] = int(obj.find('truncated').text)
+    obj_struct['difficult'] = int(obj.find('difficult').text)
+    bbox = obj.find('bndbox')
+    obj_struct['bbox'] = [int(bbox.find('xmin').text),
+                          int(bbox.find('ymin').text),
+                          int(bbox.find('xmax').text),
+                          int(bbox.find('ymax').text)]
+    objects.append(obj_struct)
+
+  return objects
+
+
+def voc_ap(rec, prec, use_07_metric=False):
+  """ ap = voc_ap(rec, prec, [use_07_metric])
+  Compute VOC AP given precision and recall.
+  If use_07_metric is true, uses the
+  VOC 07 11 point method (default:False).
+  """
+  if use_07_metric:
+    # 11 point metric
+    ap = 0.
+    for t in np.arange(0., 1.1, 0.1):
+      if np.sum(rec >= t) == 0:
+        p = 0
+      else:
+        p = np.max(prec[rec >= t])
+      ap = ap + p / 11.
+  else:
+    # correct AP calculation
+    # first append sentinel values at the end
+    mrec = np.concatenate(([0.], rec, [1.]))
+    mpre = np.concatenate(([0.], prec, [0.]))
+
+    # compute the precision envelope
+    for i in range(mpre.size - 1, 0, -1):
+      mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i])
+
+    # to calculate area under PR curve, look for points
+    # where X axis (recall) changes value
+    i = np.where(mrec[1:] != mrec[:-1])[0]
+
+    # and sum (\Delta recall) * prec
+    ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1])
+  return ap
+
+
+def voc_eval(detpath, annopath, test_imgid_list, cls_name, ovthresh=0.5,
+                 use_07_metric=False, use_diff=False):
+  '''
+
+  :param detpath:
+  :param annopath:
+  :param test_imgid_list: it 's a list that contains the img_name of test_imgs
+  :param cls_name:
+  :param ovthresh:
+  :param use_07_metric:
+  :param use_diff:
+  :return:
+  '''
+  # 1. parse xml to get gtboxes
+
+  # read list of images
+  imagenames = test_imgid_list
+
+  recs = {}
+  for i, imagename in enumerate(imagenames):
+    recs[imagename] = parse_rec(os.path.join(annopath, imagename+'.xml'))
+    # if i % 100 == 0:
+    #   print('Reading annotation for {:d}/{:d}'.format(
+    #     i + 1, len(imagenames)))
+
+  # 2. get gtboxes for this class.
+  class_recs = {}
+  num_pos = 0
+  # if cls_name == 'person':
+  #   print ("aaa")
+  for imagename in imagenames:
+    R = [obj for obj in recs[imagename] if obj['name'] == cls_name]
+    bbox = np.array([x['bbox'] for x in R])
+    if use_diff:
+      difficult = np.array([False for x in R]).astype(np.bool)
+    else:
+      difficult = np.array([x['difficult'] for x in R]).astype(np.bool)
+    det = [False] * len(R)
+    num_pos = num_pos + sum(~difficult)  # ignored the diffcult boxes
+    class_recs[imagename] = {'bbox': bbox,
+                             'difficult': difficult,
+                             'det': det} # det means that gtboxes has already been detected
+
+  # 3. read the detection file
+  detfile = os.path.join(detpath, "det_"+cls_name+".txt")
+  with open(detfile, 'r') as f:
+    lines = f.readlines()
+
+  # for a line. that is [img_name, confidence, xmin, ymin, xmax, ymax]
+  splitlines = [x.strip().split(' ') for x in lines]  # a list that include a list
+  image_ids = [x[0] for x in splitlines]  # img_id is img_name
+  confidence = np.array([float(x[1]) for x in splitlines])
+  BB = np.array([[float(z) for z in x[2:]] for x in splitlines])
+
+  nd = len(image_ids) # num of detections. That, a line is a det_box.
+  tp = np.zeros(nd)
+  fp = np.zeros(nd)
+
+  if BB.shape[0] > 0:
+    # sort by confidence
+    sorted_ind = np.argsort(-confidence)
+    sorted_scores = np.sort(-confidence)
+    BB = BB[sorted_ind, :]
+    image_ids = [image_ids[x] for x in sorted_ind]  #reorder the img_name
+
+    # go down dets and mark TPs and FPs
+    for d in range(nd):
+      R = class_recs[image_ids[d]]  # img_id is img_name
+      bb = BB[d, :].astype(float)
+      ovmax = -np.inf
+      BBGT = R['bbox'].astype(float)
+
+      if BBGT.size > 0:
+        # compute overlaps
+        # intersection
+        ixmin = np.maximum(BBGT[:, 0], bb[0])
+        iymin = np.maximum(BBGT[:, 1], bb[1])
+        ixmax = np.minimum(BBGT[:, 2], bb[2])
+        iymax = np.minimum(BBGT[:, 3], bb[3])
+        iw = np.maximum(ixmax - ixmin + 1., 0.)
+        ih = np.maximum(iymax - iymin + 1., 0.)
+        inters = iw * ih
+
+        # union
+        uni = ((bb[2] - bb[0] + 1.) * (bb[3] - bb[1] + 1.) +
+               (BBGT[:, 2] - BBGT[:, 0] + 1.) *
+               (BBGT[:, 3] - BBGT[:, 1] + 1.) - inters)
+
+        overlaps = inters / uni
+        ovmax = np.max(overlaps)
+        jmax = np.argmax(overlaps)
+
+      if ovmax > ovthresh:
+        if not R['difficult'][jmax]:
+          if not R['det'][jmax]:
+            tp[d] = 1.
+            R['det'][jmax] = 1
+          else:
+            fp[d] = 1.
+      else:
+        fp[d] = 1.
+
+  # 4. get recall, precison and AP
+  fp = np.cumsum(fp)
+  tp = np.cumsum(tp)
+  rec = tp / float(num_pos)
+  # avoid divide by zero in case the first detection matches a difficult
+  # ground truth
+  prec = tp / np.maximum(tp + fp, np.finfo(np.float64).eps)
+  ap = voc_ap(rec, prec, use_07_metric=cfgs.USE_07_METRIC)
+
+  return rec, prec, ap
+
+
+def do_python_eval(test_imgid_list, test_annotation_path):
+  AP_list = []
+  #import matplotlib.pyplot as plt
+  #import matplotlib.colors as colors
+  #color_list = colors.cnames.keys()[::6]
+
+  for cls, index in NAME_LABEL_MAP.items():
+    if cls == 'back_ground':
+      continue
+    recall, precision, AP = voc_eval(detpath=os.path.join(cfgs.EVALUATE_DIR, cfgs.VERSION),
+                                     test_imgid_list=test_imgid_list,
+                                     cls_name=cls,
+                                     annopath=test_annotation_path)
+    AP_list += [AP]
+    pl.plot(recall, precision, lw=2, label='{} (AP = {:.4f})'''.format(cls, AP))
+    print(10*"__")
+  pl.xlabel('Recall')
+  pl.ylabel('Precision')
+  pl.grid(True)
+  pl.ylim([0.0, 1.05])
+  pl.xlim([0.0, 1.0])
+  pl.title('Precision-Recall')
+  pl.legend(loc="lower left")     
+  pl.show()
+  pl.savefig(cfgs.VERSION+'_eval.jpg')
+  print("hello")
+  print("mAP is : {}".format(np.mean(AP_list)))
+
+
+def voc_evaluate_detections(all_boxes, test_annotation_path, test_imgid_list):
+  '''
+
+  :param all_boxes: is a list. each item reprensent the detections of a img.
+
+  The detections is a array. shape is [-1, 6]. [category, score, xmin, ymin, xmax, ymax]
+  Note that: if none detections in this img. that the detetions is : []
+  :return:
+  '''
+  test_imgid_list = [item.split('.')[0] for item in test_imgid_list]
+
+  write_voc_results_file(all_boxes, test_imgid_list=test_imgid_list,
+                         det_save_dir=os.path.join(cfgs.EVALUATE_DIR, cfgs.VERSION))
+  do_python_eval(test_imgid_list, test_annotation_path=test_annotation_path)
+
+
+
+
+
+
+
+
diff --git a/example-apps/PDD/pcb-defect-detection/output/.gitignore b/example-apps/PDD/pcb-defect-detection/output/.gitignore
new file mode 100755
index 0000000..71cea80
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/output/.gitignore
@@ -0,0 +1,3 @@
+# ignore all except .gitignore file
+*
+!.gitignore
\ No newline at end of file
diff --git a/example-apps/PDD/pcb-defect-detection/pcb-be-k8s.yaml b/example-apps/PDD/pcb-defect-detection/pcb-be-k8s.yaml
new file mode 100644
index 0000000..b4411a0
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/pcb-be-k8s.yaml
@@ -0,0 +1,86 @@
+# Copyright 2020 Huawei Technologies Co., Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: pcbdefdet-be
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: pcbdefdet
+  template:
+    metadata:
+      labels:
+        app: pcbdefdet
+    spec:
+      containers:
+        - name: pcbdefdet-be
+          image: ealtedge/pcbdefdet-be
+          ports:
+            - containerPort: 9991
+          volumeMounts:
+            - name: host-path-storage
+              mountPath: "/usr/app/data/pretrained_weights"
+            - name: host-path-storage
+              mountPath: "/usr/app/output/trained_weights/FPN_Res101_0117_OHEM"
+      volumes:
+        - name: host-path-storage
+          persistentVolumeClaim:
+            claimName: host-path-claim
+
+---
+apiVersion: v1
+kind: PersistentVolume
+metadata:
+  name: host-path-pv
+  labels:
+    type: local
+spec:
+  storageClassName: manual
+  capacity:
+    storage: 2Gi
+  accessModes:
+    - ReadWriteOnce
+  hostPath:
+    path: "/root/pcb-def-det/model/"
+
+---
+apiVersion: v1
+kind: PersistentVolumeClaim
+metadata:
+  name: host-path-claim
+spec:
+  storageClassName: manual
+  accessModes:
+    - ReadWriteOnce
+  resources:
+    requests:
+      storage: 2Gi
+
+# backup-be serice
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: pcbdefdet-be
+spec:
+  selector:
+    app: pcbdefdet
+  type: NodePort
+  ports:
+    - port: 9991
+      name: service-port
+      nodePort: 30281
diff --git a/example-apps/PDD/pcb-defect-detection/requirements.txt b/example-apps/PDD/pcb-defect-detection/requirements.txt
new file mode 100644
index 0000000..99df291
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/requirements.txt
@@ -0,0 +1,25 @@
+#
+# Copyright 2020 Huawei Technologies Co., Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+flask~=1.1.2
+requests~=2.18.4
+flask_sslify
+opencv-python~=3.3.1.11
+flask_cors
+numpy
+Wand
+tensorflow-plot
+tensorflow~=1.12
\ No newline at end of file
diff --git a/example-apps/PDD/pcb-defect-detection/requirements_1.txt b/example-apps/PDD/pcb-defect-detection/requirements_1.txt
new file mode 100644
index 0000000..32aa95e
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/requirements_1.txt
@@ -0,0 +1,17 @@
+#
+# Copyright 2020 Huawei Technologies Co., Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+PIL
\ No newline at end of file
diff --git a/example-apps/PDD/pcb-defect-detection/run.py b/example-apps/PDD/pcb-defect-detection/run.py
new file mode 100644
index 0000000..54508b3
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/run.py
@@ -0,0 +1,25 @@
+#
+# Copyright 2020 Huawei Technologies Co., Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+import logging
+from logging.handlers import RotatingFileHandler
+from tools.application import start_server
+
+if __name__ == '__main__':
+    handler = RotatingFileHandler('/usr/app/log/defect_detection.log',
+                                  maxBytes=10000000, backupCount=10)
+    handler.setLevel(logging.INFO)
+    start_server(handler)
diff --git a/example-apps/PDD/pcb-defect-detection/tools/__init__.py b/example-apps/PDD/pcb-defect-detection/tools/__init__.py
new file mode 100755
index 0000000..e69de29
diff --git a/example-apps/PDD/pcb-defect-detection/tools/__init__.pyc b/example-apps/PDD/pcb-defect-detection/tools/__init__.pyc
new file mode 100644
index 0000000..0c03069
Binary files /dev/null and b/example-apps/PDD/pcb-defect-detection/tools/__init__.pyc differ
diff --git a/example-apps/PDD/pcb-defect-detection/tools/application.py b/example-apps/PDD/pcb-defect-detection/tools/application.py
new file mode 100644
index 0000000..b1da1a2
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/tools/application.py
@@ -0,0 +1,179 @@
+
+import config
+from flask_sslify import SSLify
+from flask import Flask, request, jsonify, Response
+from flask_cors import CORS
+
+import json
+import requests
+import os
+import os.path
+from os import path
+import base64
+import sys
+
+app = Flask(__name__)
+CORS(app)
+sslify = SSLify(app)
+app.config['JSON_AS_ASCII'] = False
+app.config['INPUT_IMAGE_PATH'] = '/usr/app/input_image/'
+app.config['OUTPUT_IMAGE_PATH'] = '/usr/app/output_image/'
+
+app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024
+ALLOWED_EXTENSIONS = set(['png', 'jpg', 'jpeg'])
+count = 0
+listOfPath = []
+listOfImages = []
+mock_func = 0
+# result_image_path = app.config['OUTPUT_IMAGE_PATH']
+
+listOfPath = ["beijinglab/camera1", "beijinglab/camera2",
+              "beijinglab/camera3",
+              "shenzhenlab/camera1", "shenzhenlab/camera2",
+              "shenzhenlab/camera3",
+              "shanghailab/camera1", "shanghailab/camera2",
+              "shanghailab/camera3"]
+
+def path_exist(image_path):
+    print('image path:',image_path)
+
+    pathexist = 0
+    for imagepath in listOfPath:
+        print('image path in list:', imagepath)
+        if (image_path == imagepath):
+            print('image path match')
+            pathexist = 1
+            break
+
+    return pathexist
+
+def get_images(abs_image_path):
+    """
+    preview images
+
+    :return: result image
+    """
+    del listOfImages[:]
+
+    arr = os.listdir(abs_image_path)
+    for file in arr:
+        print('image name:',abs_image_path + file)
+
+    for image in arr:
+        ## as base64 string
+        with open(abs_image_path + image, "rb") as img_file:
+            jpeg_bin = base64.b64encode(img_file.read())
+            listOfImages.append(jpeg_bin)
+
+    response = {'image01': listOfImages[0],
+                'image02': listOfImages[1],
+                'image03': listOfImages[2],}
+                #'image04': listOfImages[3]}
+               # 'image05': listOfImages[4],}
+
+    return response
+
+def detection(input_image_path, output_image_path):
+    """
+    detection
+
+    :return: detection status
+    """
+    cmd = 'cd tools' + ' && python inference.py --data_dir=' + \
+          input_image_path + ' --save_dir=' + output_image_path + ' --GPU=0'
+    print(cmd)
+
+    os.system(cmd)
+    return 1
+
+
+@app.route('/v1/pcb/preview/<EdgeLoc>/<cameraNum>', methods=['GET'])
+def preview_image(EdgeLoc, cameraNum):
+    """
+    preview images
+
+    :return: result image
+    """
+    app.logger.info("Received message from ClientIP [" + request.remote_addr
+                    + "] Operation [" + request.method + "]" +
+                    " Resource [" + request.url + "]")
+
+    image_path = EdgeLoc + '/' + cameraNum
+    pathexist = path_exist(image_path)
+    if pathexist == 0:
+        response = {'image' : 'null'}
+        print ('image path not exist:',image_path)
+        return jsonify(response)
+
+    abs_image_path = app.config['INPUT_IMAGE_PATH'] + image_path + '/'
+    print('abs image path:',abs_image_path)
+    response = get_images(abs_image_path)
+
+    return jsonify(response)
+
+
+@app.route('/v1/pcb/resultimage', methods=['GET'])
+def result_image():
+    """
+    preview images
+
+    :return: result image
+    """
+    app.logger.info("Received message from ClientIP [" + request.remote_addr
+                    + "] Operation [" + request.method + "]" +
+                    " Resource [" + request.url + "]")
+
+    print('result image path global:',result_image_path)
+    response = get_images(result_image_path)
+
+    return jsonify(response)
+
+
+@app.route('/v1/pcb/detection/<EdgeLoc>/<cameraNum>', methods=['GET'])
+def detect_image(EdgeLoc, cameraNum):
+    """
+    detect images
+
+    :return: success or failure
+    """
+    app.logger.info("Received message from ClientIP [" + request.remote_addr
+                    + "] Operation [" + request.method + "]" +
+                    " Resource [" + request.url + "]")
+    global result_image_path
+
+    image_path = EdgeLoc + '/' + cameraNum
+    pathexist = path_exist(image_path)
+    if pathexist == 0:
+        response = {'responce': 'failure'}
+        print ('image path not exist:',image_path)
+        return jsonify(response)
+
+    input_image_path = app.config['INPUT_IMAGE_PATH'] + image_path + '/'
+    print('input image path:', input_image_path)
+
+    output_image_path = app.config['OUTPUT_IMAGE_PATH'] + image_path + '/'
+    print('out image path:', output_image_path)
+
+    ret = detection(input_image_path, output_image_path)
+    if (ret == 0):
+        response = {'responce': 'failure'}
+        print('detectio algo failed ')
+        return jsonify(response)
+
+    result_image_path = output_image_path
+    print('result image path:', result_image_path)
+
+    response = {'responce': 'success'}
+    print('detection sucess')
+    return jsonify(response)
+
+
+def start_server(handler):
+    app.logger.addHandler(handler)
+    if config.ssl_enabled:
+        context = (config.ssl_certfilepath, config.ssl_keyfilepath)
+        app.run(host=config.server_address, debug=True, ssl_context=context,
+                threaded=True, port=config.server_port)
+    else:
+        app.run(host=config.server_address, debug=True, threaded=True,
+                port=config.server_port)
diff --git a/example-apps/PDD/pcb-defect-detection/tools/eval.py b/example-apps/PDD/pcb-defect-detection/tools/eval.py
new file mode 100755
index 0000000..e496e30
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/tools/eval.py
@@ -0,0 +1,201 @@
+# -*- coding:utf-8 -*-
+
+from __future__ import absolute_import
+from __future__ import print_function
+from __future__ import division
+
+import os, sys
+import tensorflow as tf
+import time
+import cv2
+import pickle
+import numpy as np
+sys.path.append("../")
+
+from data.io.image_preprocess import short_side_resize_for_inference_data
+from libs.configs import cfgs
+from libs.networks import build_whole_network
+from libs.val_libs import voc_eval
+from libs.box_utils import draw_box_in_img
+import argparse
+from help_utils import tools
+
+
+def eval_with_plac(det_net, real_test_imgname_list, img_root, draw_imgs=False):
+
+    # 1. preprocess img
+    img_plac = tf.placeholder(dtype=tf.uint8, shape=[None, None, 3])  # is RGB. not BGR
+    img_batch = tf.cast(img_plac, tf.float32)
+
+    img_batch = short_side_resize_for_inference_data(img_tensor=img_batch,
+                                                     target_shortside_len=cfgs.IMG_SHORT_SIDE_LEN,
+                                                     length_limitation=cfgs.IMG_MAX_LENGTH)
+    img_batch = img_batch - tf.constant(cfgs.PIXEL_MEAN)
+    img_batch = tf.expand_dims(img_batch, axis=0)
+
+    detection_boxes, detection_scores, detection_category = det_net.build_whole_detection_network(
+        input_img_batch=img_batch,
+        gtboxes_batch=None)
+
+    init_op = tf.group(
+        tf.global_variables_initializer(),
+        tf.local_variables_initializer()
+    )
+
+    restorer, restore_ckpt = det_net.get_restorer()
+
+    config = tf.ConfigProto()
+    config.gpu_options.allow_growth = True
+
+    compute_time = 0
+    compute_imgnum = 0
+
+    with tf.Session(config=config) as sess:
+        sess.run(init_op)
+        if not restorer is None:
+            restorer.restore(sess, restore_ckpt)
+            print('restore model')
+
+        all_boxes = []
+        for i, a_img_name in enumerate(real_test_imgname_list):
+
+            raw_img = cv2.imread(os.path.join(img_root, a_img_name))
+            raw_h, raw_w = raw_img.shape[0], raw_img.shape[1]
+
+            start = time.time()
+            resized_img, detected_boxes, detected_scores, detected_categories = \
+                sess.run(
+                    [img_batch, detection_boxes, detection_scores, detection_category],
+                    feed_dict={img_plac: raw_img[:, :, ::-1]}  # cv is BGR. But need RGB
+                )
+            end = time.time()
+            compute_time = compute_time + (end - start)
+            compute_imgnum = compute_imgnum + 1
+            # print("{} cost time : {} ".format(img_name, (end - start)))
+            if draw_imgs:
+                show_indices = detected_scores >= cfgs.SHOW_SCORE_THRSHOLD
+                show_scores = detected_scores[show_indices]
+                show_boxes = detected_boxes[show_indices]
+                show_categories = detected_categories[show_indices]
+                final_detections = draw_box_in_img.draw_boxes_with_label_and_scores(np.squeeze(resized_img, 0),
+                                                                                    boxes=show_boxes,
+                                                                                    labels=show_categories,
+                                                                                    scores=show_scores)
+                if not os.path.exists(cfgs.TEST_SAVE_PATH):
+                    os.makedirs(cfgs.TEST_SAVE_PATH)
+
+                cv2.imwrite(cfgs.TEST_SAVE_PATH + '/' + a_img_name + '.jpg',
+                            final_detections[:, :, ::-1])
+
+            xmin, ymin, xmax, ymax = detected_boxes[:, 0], detected_boxes[:, 1], \
+                                     detected_boxes[:, 2], detected_boxes[:, 3]
+
+            resized_h, resized_w = resized_img.shape[1], resized_img.shape[2]
+
+            xmin = xmin * raw_w / resized_w
+            xmax = xmax * raw_w / resized_w
+
+            ymin = ymin * raw_h / resized_h
+            ymax = ymax * raw_h / resized_h
+
+            boxes = np.transpose(np.stack([xmin, ymin, xmax, ymax]))
+            dets = np.hstack((detected_categories.reshape(-1, 1),
+                              detected_scores.reshape(-1, 1),
+                              boxes))
+            all_boxes.append(dets)
+
+            tools.view_bar('{} image cost {}s'.format(a_img_name, (end - start)), i + 1, len(real_test_imgname_list))
+
+        # save_dir = os.path.join(cfgs.EVALUATE_DIR, cfgs.VERSION)
+        # if not os.path.exists(save_dir):
+        #     os.makedirs(save_dir)
+        # fw1 = open(os.path.join(save_dir, 'detections.pkl'), 'wb')
+        # pickle.dump(all_boxes, fw1)
+        print('\n average_training_time_per_image is' + str(compute_time / compute_imgnum))
+        return all_boxes
+
+
+def eval(num_imgs, eval_dir, annotation_dir, showbox):
+
+    # with open('/home/yjr/DataSet/VOC/VOC_test/VOC2007/ImageSets/Main/aeroplane_test.txt') as f:
+    #     all_lines = f.readlines()
+    # test_imgname_list = [a_line.split()[0].strip() for a_line in all_lines]
+
+    test_imgname_list = [item for item in os.listdir(eval_dir)
+                              if item.endswith(('.jpg', 'jpeg', '.png', '.tif', '.tiff'))]
+    if num_imgs == np.inf:
+        real_test_imgname_list = test_imgname_list
+    else:
+        real_test_imgname_list = test_imgname_list[: num_imgs]
+
+    faster_rcnn = build_whole_network.DetectionNetwork(base_network_name=cfgs.NET_NAME,
+                                                       is_training=False)
+    all_boxes = eval_with_plac(det_net=faster_rcnn, real_test_imgname_list=real_test_imgname_list,
+                   img_root=eval_dir,
+                   draw_imgs=showbox)
+
+    # save_dir = os.path.join(cfgs.EVALUATE_DIR, cfgs.VERSION)
+    # if not os.path.exists(save_dir):
+    #     os.makedirs(save_dir)
+    # with open(os.path.join(save_dir, 'detections.pkl'), 'rb') as f:
+    #     all_boxes = pickle.load(f)
+    #
+    #     print(len(all_boxes))
+
+    voc_eval.voc_evaluate_detections(all_boxes=all_boxes,
+                                     test_annotation_path=annotation_dir,
+                                     test_imgid_list=real_test_imgname_list)
+
+def parse_args():
+
+    parser = argparse.ArgumentParser('evaluate the result with Pascal2007 stdand')
+
+    parser.add_argument('--eval_imgs', dest='eval_imgs',
+                        help='evaluate imgs dir ',
+                        default='../data/pcb_test/JPEGImages', type=str)
+    parser.add_argument('--annotation_dir', dest='test_annotation_dir',
+                        help='the dir save annotations',
+                        default='../data/pcb_test/Annotations', type=str)
+    parser.add_argument('--showbox', dest='showbox',
+                        help='whether show detecion results when evaluation',
+                        default=False, type=bool)
+    parser.add_argument('--GPU', dest='GPU',
+                        help='gpu id',
+                        default='2', type=str)
+    #parser.add_argument('--eval_num', dest='eval_num',
+    #                    help='the num of eval imgs',
+    #                    default=np.inf, type=int)
+    parser.add_argument('--eval_num', dest='eval_num',
+                        help='the num of eval imgs',
+                        default=100, type=int)
+    args = parser.parse_args()
+    return args
+
+
+if __name__ == '__main__':
+
+    args = parse_args()
+    print(20*"--")
+    print(args)
+    print(20*"--")
+    os.environ["CUDA_VISIBLE_DEVICES"] = args.GPU
+    eval(np.inf,  # use np.inf to test all the imgs. use 10 to test 10 imgs.
+         eval_dir=args.eval_imgs,
+         annotation_dir=args.test_annotation_dir,
+         showbox=args.showbox)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/example-apps/PDD/pcb-defect-detection/tools/inference.py b/example-apps/PDD/pcb-defect-detection/tools/inference.py
new file mode 100755
index 0000000..e525d46
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/tools/inference.py
@@ -0,0 +1,139 @@
+# -*- coding:utf-8 -*-
+
+from __future__ import absolute_import
+from __future__ import print_function
+from __future__ import division
+
+import os, sys
+import tensorflow as tf
+import time
+import cv2
+import argparse
+import numpy as np
+sys.path.append("../")
+
+from data.io.image_preprocess import short_side_resize_for_inference_data
+from libs.configs import cfgs
+from libs.networks import build_whole_network
+from libs.box_utils import draw_box_in_img
+from help_utils import tools
+
+
+def detect(det_net, inference_save_path, real_test_imgname_list):
+
+    # 1. preprocess img
+    img_plac = tf.placeholder(dtype=tf.uint8, shape=[None, None, 3])  # is RGB. not GBR
+    img_batch = tf.cast(img_plac, tf.float32)
+    img_batch = short_side_resize_for_inference_data(img_tensor=img_batch,
+                                                     target_shortside_len=cfgs.IMG_SHORT_SIDE_LEN,
+                                                     length_limitation=cfgs.IMG_MAX_LENGTH)
+    img_batch = img_batch - tf.constant(cfgs.PIXEL_MEAN)
+    img_batch = tf.expand_dims(img_batch, axis=0) # [1, None, None, 3]
+
+    detection_boxes, detection_scores, detection_category = det_net.build_whole_detection_network(
+        input_img_batch=img_batch,
+        gtboxes_batch=None)
+
+    init_op = tf.group(
+        tf.global_variables_initializer(),
+        tf.local_variables_initializer()
+    )
+
+    restorer, restore_ckpt = det_net.get_restorer()
+
+    config = tf.ConfigProto()
+    config.gpu_options.allow_growth = True
+
+    with tf.Session(config=config) as sess:
+        sess.run(init_op)
+        if not restorer is None:
+            restorer.restore(sess, restore_ckpt)
+            print('restore model')
+
+        for i, a_img_name in enumerate(real_test_imgname_list):
+
+            raw_img = cv2.imread(a_img_name)
+            start = time.time()
+            resized_img, detected_boxes, detected_scores, detected_categories = \
+                sess.run(
+                    [img_batch, detection_boxes, detection_scores, detection_category],
+                    feed_dict={img_plac: raw_img[:, :, ::-1]}  # cv is BGR. But need RGB
+                )
+            end = time.time()
+            # print("{} cost time : {} ".format(img_name, (end - start)))
+
+            show_indices = detected_scores >= cfgs.SHOW_SCORE_THRSHOLD
+            show_scores = detected_scores[show_indices]
+            show_boxes = detected_boxes[show_indices]
+            show_categories = detected_categories[show_indices]
+            final_detections = draw_box_in_img.draw_boxes_with_label_and_scores(np.squeeze(resized_img, 0),
+                                                                                boxes=show_boxes,
+                                                                                labels=show_categories,
+                                                                                scores=show_scores)
+            nake_name = a_img_name.split('/')[-1]
+            # print (inference_save_path + '/' + nake_name)
+            cv2.imwrite(inference_save_path + '/' + nake_name,
+                        final_detections[:, :, ::-1])
+
+            tools.view_bar('{} image cost {}s'.format(a_img_name, (end - start)), i + 1, len(real_test_imgname_list))
+
+
+def inference(test_dir, inference_save_path):
+
+    test_imgname_list = [os.path.join(test_dir, img_name) for img_name in os.listdir(test_dir)
+                                                          if img_name.endswith(('.jpg', '.png', '.jpeg', '.tif', '.tiff'))]
+    assert len(test_imgname_list) != 0, 'test_dir has no imgs there.' \
+                                        ' Note that, we only support img format of (.jpg, .png, and .tiff) '
+
+    faster_rcnn = build_whole_network.DetectionNetwork(base_network_name=cfgs.NET_NAME,
+                                                       is_training=False)
+    detect(det_net=faster_rcnn, inference_save_path=inference_save_path, real_test_imgname_list=test_imgname_list)
+
+
+def parse_args():
+    """
+    Parse input arguments
+    """
+    parser = argparse.ArgumentParser(description='TestImgs...U need provide the test dir')
+
+    parser.add_argument('--data_dir', dest='data_dir',
+                        help='data path',
+                        default='demos', type=str)
+    parser.add_argument('--save_dir', dest='save_dir',
+                        help='demo imgs to save',
+                        default='inference_results', type=str)
+    parser.add_argument('--GPU', dest='GPU',
+                        help='gpu id ',
+                        default='0', type=str)
+
+    if len(sys.argv) == 1:
+        parser.print_help()
+        sys.exit(1)
+
+    args = parser.parse_args()
+
+    return args
+if __name__ == '__main__':
+
+    args = parse_args()
+    print('Called with args:')
+    print(args)
+    os.environ["CUDA_VISIBLE_DEVICES"] = args.GPU
+    inference(args.data_dir,
+              inference_save_path=args.save_dir)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/example-apps/PDD/pcb-defect-detection/tools/inference_for_coco.py b/example-apps/PDD/pcb-defect-detection/tools/inference_for_coco.py
new file mode 100755
index 0000000..835f251
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/tools/inference_for_coco.py
@@ -0,0 +1,179 @@
+# -*- coding:utf-8 -*-
+
+from __future__ import absolute_import
+from __future__ import print_function
+from __future__ import division
+
+import os, sys
+import tensorflow as tf
+import time
+import cv2
+import pickle
+import numpy as np
+sys.path.append("../")
+sys.path.insert(0, '/home/yjr/PycharmProjects/Faster-RCNN_TF/data/lib_coco/PythonAPI')
+from data.io.image_preprocess import short_side_resize_for_inference_data
+from libs.configs import cfgs
+from libs.networks import build_whole_network
+from libs.val_libs import voc_eval
+from libs.box_utils import draw_box_in_img
+from libs.label_name_dict.coco_dict import LABEL_NAME_MAP, classes_originID
+from help_utils import tools
+from data.lib_coco.PythonAPI.pycocotools.coco import COCO
+import json
+
+os.environ["CUDA_VISIBLE_DEVICES"] = cfgs.GPU_GROUP
+
+
+def eval_with_plac(det_net, imgId_list, coco, out_json_root, draw_imgs=False):
+
+    # 1. preprocess img
+    img_plac = tf.placeholder(dtype=tf.uint8, shape=[None, None, 3])  # is RGB. not GBR
+    img_batch = tf.cast(img_plac, tf.float32)
+
+    img_batch = short_side_resize_for_inference_data(img_tensor=img_batch,
+                                                     target_shortside_len=cfgs.IMG_SHORT_SIDE_LEN,
+                                                     length_limitation=cfgs.IMG_MAX_LENGTH)
+    img_batch = img_batch - tf.constant(cfgs.PIXEL_MEAN)
+    img_batch = tf.expand_dims(img_batch, axis=0)
+
+    detection_boxes, detection_scores, detection_category = det_net.build_whole_detection_network(
+        input_img_batch=img_batch,
+        gtboxes_batch=None)
+
+    init_op = tf.group(
+        tf.global_variables_initializer(),
+        tf.local_variables_initializer()
+    )
+
+    restorer, restore_ckpt = det_net.get_restorer()
+
+    config = tf.ConfigProto()
+    config.gpu_options.allow_growth = True
+
+    # coco_test_results = []
+
+    with tf.Session(config=config) as sess:
+        sess.run(init_op)
+        if not restorer is None:
+            restorer.restore(sess, restore_ckpt)
+            print('restore model')
+
+        for i, imgid in enumerate(imgId_list):
+            imgname = coco.loadImgs(ids=[imgid])[0]['file_name']
+            raw_img = cv2.imread(os.path.join("/home/yjr/DataSet/COCO/2017/test2017", imgname))
+
+            raw_h, raw_w = raw_img.shape[0], raw_img.shape[1]
+            start = time.time()
+            resized_img, detected_boxes, detected_scores, detected_categories = \
+                sess.run(
+                    [img_batch, detection_boxes, detection_scores, detection_category],
+                    feed_dict={img_plac: raw_img[:, :, ::-1]}  # cv is BGR. But need RGB
+                )
+            end = time.time()
+
+            if draw_imgs:
+                show_indices = detected_scores >= cfgs.SHOW_SCORE_THRSHOLD
+                show_scores = detected_scores[show_indices]
+                show_boxes = detected_boxes[show_indices]
+                show_categories = detected_categories[show_indices]
+                final_detections = draw_box_in_img.draw_boxes_with_label_and_scores(np.squeeze(resized_img, 0),
+                                                                                    boxes=show_boxes,
+                                                                                    labels=show_categories,
+                                                                                    scores=show_scores)
+                cv2.imwrite(cfgs.TEST_SAVE_PATH + '/' + str(imgid) + '.jpg',
+                            final_detections[:, :, ::-1])
+
+            xmin, ymin, xmax, ymax = detected_boxes[:, 0], detected_boxes[:, 1], \
+                                     detected_boxes[:, 2], detected_boxes[:, 3]
+
+            resized_h, resized_w = resized_img.shape[1], resized_img.shape[2]
+
+            xmin = xmin * raw_w / resized_w
+            xmax = xmax * raw_w / resized_w
+
+            ymin = ymin * raw_h / resized_h
+            ymax = ymax * raw_h / resized_h
+
+            boxes = np.transpose(np.stack([xmin, ymin, xmax-xmin, ymax-ymin]))
+
+            dets = np.hstack((detected_categories.reshape(-1, 1),
+                              detected_scores.reshape(-1, 1),
+                              boxes))
+
+            a_img_detect_result = []
+            for a_det in dets:
+                label, score, bbox = a_det[0], a_det[1], a_det[2:]
+                cat_id = classes_originID[LABEL_NAME_MAP[label]]
+                if score<0.00001:
+                   continue
+                det_object = {"image_id": imgid,
+                              "category_id": cat_id,
+                              "bbox": bbox.tolist(),
+                              "score": float(score)}
+                # print (det_object)
+                a_img_detect_result.append(det_object)
+            f = open(os.path.join(out_json_root, 'each_img', str(imgid)+'.json'), 'w')
+            json.dump(a_img_detect_result, f)  # , indent=4
+            f.close()
+            del a_img_detect_result
+            del dets
+            del boxes
+            del resized_img
+            del raw_img
+            tools.view_bar('{} image cost {}s'.format(imgid, (end - start)), i + 1, len(imgId_list))
+
+
+def eval(num_imgs):
+
+
+   # annotation_path = '/home/yjr/DataSet/COCO/2017/test_annotations/image_info_test2017.json'
+    annotation_path = '/home/yjr/DataSet/COCO/2017/test_annotations/image_info_test-dev2017.json'
+    # annotation_path = '/home/yjr/DataSet/COCO/2017/annotations/instances_train2017.json'
+    print("load coco .... it will cost about 17s..")
+    coco = COCO(annotation_path)
+
+    imgId_list = coco.getImgIds()
+
+    if num_imgs !=np.inf:
+        imgId_list = imgId_list[: num_imgs]
+
+    faster_rcnn = build_whole_network.DetectionNetwork(base_network_name=cfgs.NET_NAME,
+                                                       is_training=False)
+    save_dir = os.path.join(cfgs.EVALUATE_DIR, cfgs.VERSION)
+    eval_with_plac(det_net=faster_rcnn, coco=coco, imgId_list=imgId_list, out_json_root=save_dir,
+                   draw_imgs=True)
+    print("each img over**************")
+
+    final_detections = []
+    with open(os.path.join(save_dir, 'coco2017test_results.json'), 'w') as wf:
+        for imgid in imgId_list:
+            f = open(os.path.join(save_dir, 'each_img', str(imgid)+'.json'))
+            tmp_list = json.load(f)
+            # print (type(tmp_list))
+            final_detections.extend(tmp_list)
+            del tmp_list
+            f.close()
+        json.dump(final_detections, wf)
+
+
+if __name__ == '__main__':
+
+    eval(np.inf)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/example-apps/PDD/pcb-defect-detection/tools/test.py b/example-apps/PDD/pcb-defect-detection/tools/test.py
new file mode 100755
index 0000000..86984d9
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/tools/test.py
@@ -0,0 +1,153 @@
+# -*- coding:utf-8 -*-
+
+from __future__ import absolute_import
+from __future__ import print_function
+from __future__ import division
+
+import os, sys
+import tensorflow as tf
+import time
+import cv2
+import argparse
+import numpy as np
+sys.path.append("../")
+
+from data.io.image_preprocess import short_side_resize_for_inference_data
+from libs.configs import cfgs
+from libs.networks import build_whole_network
+from libs.box_utils import draw_box_in_img
+from help_utils import tools
+
+
+def detect(det_net, inference_save_path, real_test_imgname_list):
+
+    # 1. preprocess img
+    img_plac = tf.placeholder(dtype=tf.uint8, shape=[None, None, 3])  # is RGB. not GBR
+    img_batch = tf.cast(img_plac, tf.float32)
+    img_batch = short_side_resize_for_inference_data(img_tensor=img_batch,
+                                                     target_shortside_len=cfgs.IMG_SHORT_SIDE_LEN,
+                                                     length_limitation=cfgs.IMG_MAX_LENGTH)
+    img_batch = img_batch - tf.constant(cfgs.PIXEL_MEAN)
+    img_batch = tf.expand_dims(img_batch, axis=0) # [1, None, None, 3]
+
+    detection_boxes, detection_scores, detection_category = det_net.build_whole_detection_network(
+        input_img_batch=img_batch,
+        gtboxes_batch=None)
+
+    init_op = tf.group(
+        tf.global_variables_initializer(),
+        tf.local_variables_initializer()
+    )
+
+    restorer, restore_ckpt = det_net.get_restorer()
+
+    config = tf.ConfigProto()
+    config.gpu_options.allow_growth = True
+
+    with tf.Session(config=config) as sess:
+        sess.run(init_op)
+        if not restorer is None:
+            restorer.restore(sess, restore_ckpt)
+            print('restore model')
+
+        for i, a_img_name in enumerate(real_test_imgname_list):
+
+            raw_img = cv2.imread(a_img_name)
+            start = time.time()
+            resized_img, detected_boxes, detected_scores, detected_categories = \
+                sess.run(
+                    [img_batch, detection_boxes, detection_scores, detection_category],
+                    feed_dict={img_plac: raw_img[:, :, ::-1]}  # cv is BGR. But need RGB
+                )
+            end = time.time()
+            # print("{} cost time : {} ".format(img_name, (end - start)))
+
+            raw_h, raw_w = raw_img.shape[0], raw_img.shape[1]
+
+            xmin, ymin, xmax, ymax = detected_boxes[:, 0], detected_boxes[:, 1], \
+                                     detected_boxes[:, 2], detected_boxes[:, 3]
+
+            resized_h, resized_w = resized_img.shape[1], resized_img.shape[2]
+
+            xmin = xmin * raw_w / resized_w
+            xmax = xmax * raw_w / resized_w
+
+            ymin = ymin * raw_h / resized_h
+            ymax = ymax * raw_h / resized_h
+
+            detected_boxes = np.transpose(np.stack([xmin, ymin, xmax, ymax]))
+
+            show_indices = detected_scores >= cfgs.SHOW_SCORE_THRSHOLD
+            show_scores = detected_scores[show_indices]
+            show_boxes = detected_boxes[show_indices]
+            show_categories = detected_categories[show_indices]
+            final_detections = draw_box_in_img.draw_boxes_with_label_and_scores(raw_img - np.array(cfgs.PIXEL_MEAN),
+                                                                                boxes=show_boxes,
+                                                                                labels=show_categories,
+                                                                                scores=show_scores)
+            nake_name = a_img_name.split('/')[-1]
+            # print (inference_save_path + '/' + nake_name)
+            cv2.imwrite(inference_save_path + '/' + nake_name,
+                        final_detections[:, :, ::-1])
+
+            tools.view_bar('{} image cost {}s'.format(a_img_name, (end - start)), i + 1, len(real_test_imgname_list))
+
+
+def test(test_dir, inference_save_path):
+
+    test_imgname_list = [os.path.join(test_dir, img_name) for img_name in os.listdir(test_dir)
+                                                          if img_name.endswith(('.jpg', '.png', '.jpeg', '.tif', '.tiff'))]
+    assert len(test_imgname_list) != 0, 'test_dir has no imgs there.' \
+                                        ' Note that, we only support img format of (.jpg, .png, and .tiff) '
+
+    faster_rcnn = build_whole_network.DetectionNetwork(base_network_name=cfgs.NET_NAME,
+                                                       is_training=False)
+    detect(det_net=faster_rcnn, inference_save_path=inference_save_path, real_test_imgname_list=test_imgname_list)
+
+
+def parse_args():
+    """
+    Parse input arguments
+    """
+    parser = argparse.ArgumentParser(description='TestImgs...U need provide the test dir')
+    parser.add_argument('--data_dir', dest='data_dir',
+                        help='data path',
+                        default='demos', type=str)
+    parser.add_argument('--save_dir', dest='save_dir',
+                        help='demo imgs to save',
+                        default='inference_results', type=str)
+    parser.add_argument('--GPU', dest='GPU',
+                        help='gpu id ',
+                        default='0', type=str)
+
+    if len(sys.argv) == 1:
+        parser.print_help()
+        sys.exit(1)
+
+    args = parser.parse_args()
+
+    return args
+if __name__ == '__main__':
+
+    args = parse_args()
+    print('Called with args:')
+    print(args)
+    os.environ["CUDA_VISIBLE_DEVICES"] = args.GPU
+    test(args.data_dir,
+         inference_save_path=args.save_dir)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/example-apps/PDD/pcb-defect-detection/tools/test_annotation/01_missing_hole_01.xml b/example-apps/PDD/pcb-defect-detection/tools/test_annotation/01_missing_hole_01.xml
new file mode 100755
index 0000000..90cc96f
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/tools/test_annotation/01_missing_hole_01.xml
@@ -0,0 +1,50 @@
+<annotation>
+	<folder>Missing_hole</folder>
+	<filename>01_missing_hole_01.jpg</filename>
+	<path>/home/weapon/Desktop/PCB_DATASET/Missing_hole/01_missing_hole_01.jpg</path>
+	<source>
+		<database>Unknown</database>
+	</source>
+	<size>
+		<width>3034</width>
+		<height>1586</height>
+		<depth>3</depth>
+	</size>
+	<segmented>0</segmented>
+	<object>
+		<name>missing_hole</name>
+		<pose>Unspecified</pose>
+		<truncated>0</truncated>
+		<difficult>0</difficult>
+		<bndbox>
+			<xmin>2459</xmin>
+			<ymin>1274</ymin>
+			<xmax>2530</xmax>
+			<ymax>1329</ymax>
+		</bndbox>
+	</object>
+	<object>
+		<name>missing_hole</name>
+		<pose>Unspecified</pose>
+		<truncated>0</truncated>
+		<difficult>0</difficult>
+		<bndbox>
+			<xmin>1613</xmin>
+			<ymin>334</ymin>
+			<xmax>1679</xmax>
+			<ymax>396</ymax>
+		</bndbox>
+	</object>
+	<object>
+		<name>missing_hole</name>
+		<pose>Unspecified</pose>
+		<truncated>0</truncated>
+		<difficult>0</difficult>
+		<bndbox>
+			<xmin>1726</xmin>
+			<ymin>794</ymin>
+			<xmax>1797</xmax>
+			<ymax>854</ymax>
+		</bndbox>
+	</object>
+</annotation>
diff --git a/example-apps/PDD/pcb-defect-detection/tools/test_annotation/01_missing_hole_12.xml b/example-apps/PDD/pcb-defect-detection/tools/test_annotation/01_missing_hole_12.xml
new file mode 100755
index 0000000..b8f4aba
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/tools/test_annotation/01_missing_hole_12.xml
@@ -0,0 +1,50 @@
+<annotation>
+	<folder>Missing_hole</folder>
+	<filename>01_missing_hole_12.jpg</filename>
+	<path>/home/weapon/Desktop/PCB_DATASET/Missing_hole/01_missing_hole_12.jpg</path>
+	<source>
+		<database>Unknown</database>
+	</source>
+	<size>
+		<width>3034</width>
+		<height>1586</height>
+		<depth>3</depth>
+	</size>
+	<segmented>0</segmented>
+	<object>
+		<name>missing_hole</name>
+		<pose>Unspecified</pose>
+		<truncated>0</truncated>
+		<difficult>0</difficult>
+		<bndbox>
+			<xmin>1062</xmin>
+			<ymin>1047</ymin>
+			<xmax>1117</xmax>
+			<ymax>1112</ymax>
+		</bndbox>
+	</object>
+	<object>
+		<name>missing_hole</name>
+		<pose>Unspecified</pose>
+		<truncated>0</truncated>
+		<difficult>0</difficult>
+		<bndbox>
+			<xmin>2633</xmin>
+			<ymin>932</ymin>
+			<xmax>2702</xmax>
+			<ymax>989</ymax>
+		</bndbox>
+	</object>
+	<object>
+		<name>missing_hole</name>
+		<pose>Unspecified</pose>
+		<truncated>0</truncated>
+		<difficult>0</difficult>
+		<bndbox>
+			<xmin>2460</xmin>
+			<ymin>1220</ymin>
+			<xmax>2528</xmax>
+			<ymax>1276</ymax>
+		</bndbox>
+	</object>
+</annotation>
diff --git a/example-apps/PDD/pcb-defect-detection/tools/train.py b/example-apps/PDD/pcb-defect-detection/tools/train.py
new file mode 100755
index 0000000..c5ea76c
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/tools/train.py
@@ -0,0 +1,204 @@
+# -*- coding:utf-8 -*-
+
+from __future__ import absolute_import
+from __future__ import print_function
+from __future__ import division
+
+import tensorflow as tf
+import tensorflow.contrib.slim as slim
+import os, sys
+import numpy as np
+import time
+sys.path.append("../")
+
+from libs.configs import cfgs
+# from libs.networks import build_whole_network2
+from libs.networks import build_whole_network
+from data.io.read_tfrecord import next_batch
+from libs.box_utils import show_box_in_tensor
+from help_utils import tools
+
+os.environ["CUDA_VISIBLE_DEVICES"] = "2"
+
+
+def train():
+
+    faster_rcnn = build_whole_network.DetectionNetwork(base_network_name=cfgs.NET_NAME,
+                                                       is_training=True)
+
+    with tf.name_scope('get_batch'):
+        img_name_batch, img_batch, gtboxes_and_label_batch, num_objects_batch = \
+            next_batch(dataset_name=cfgs.DATASET_NAME,  # 'pascal', 'coco'
+                       batch_size=cfgs.BATCH_SIZE,
+                       shortside_len=cfgs.IMG_SHORT_SIDE_LEN,
+                       is_training=True)
+        gtboxes_and_label = tf.reshape(gtboxes_and_label_batch, [-1, 5])
+
+    biases_regularizer = tf.no_regularizer
+    weights_regularizer = tf.contrib.layers.l2_regularizer(cfgs.WEIGHT_DECAY)
+
+    # list as many types of layers as possible, even if they are not used now
+    with slim.arg_scope([slim.conv2d, slim.conv2d_in_plane, \
+                         slim.conv2d_transpose, slim.separable_conv2d, slim.fully_connected],
+                        weights_regularizer=weights_regularizer,
+                        biases_regularizer=biases_regularizer,
+                        biases_initializer=tf.constant_initializer(0.0)):
+        final_bbox, final_scores, final_category, loss_dict = faster_rcnn.build_whole_detection_network(
+            input_img_batch=img_batch,
+            gtboxes_batch=gtboxes_and_label)
+
+    # ----------------------------------------------------------------------------------------------------build loss
+    weight_decay_loss = tf.add_n(slim.losses.get_regularization_losses())
+    rpn_location_loss = loss_dict['rpn_loc_loss']
+    rpn_cls_loss = loss_dict['rpn_cls_loss']
+    rpn_total_loss = rpn_location_loss + rpn_cls_loss
+
+    fastrcnn_cls_loss = loss_dict['fastrcnn_cls_loss']
+    fastrcnn_loc_loss = loss_dict['fastrcnn_loc_loss']
+    fastrcnn_total_loss = fastrcnn_cls_loss + fastrcnn_loc_loss
+
+    total_loss = rpn_total_loss + fastrcnn_total_loss + weight_decay_loss
+    # ____________________________________________________________________________________________________build loss
+
+
+    # ---------------------------------------------------------------------------------------------------add summary
+
+    tf.summary.scalar('RPN_LOSS/cls_loss', rpn_cls_loss)
+    tf.summary.scalar('RPN_LOSS/location_loss', rpn_location_loss)
+    tf.summary.scalar('RPN_LOSS/rpn_total_loss', rpn_total_loss)
+
+    tf.summary.scalar('FAST_LOSS/fastrcnn_cls_loss', fastrcnn_cls_loss)
+    tf.summary.scalar('FAST_LOSS/fastrcnn_location_loss', fastrcnn_loc_loss)
+    tf.summary.scalar('FAST_LOSS/fastrcnn_total_loss', fastrcnn_total_loss)
+
+    tf.summary.scalar('LOSS/total_loss', total_loss)
+    tf.summary.scalar('LOSS/regular_weights', weight_decay_loss)
+
+    gtboxes_in_img = show_box_in_tensor.draw_boxes_with_categories(img_batch=img_batch,
+                                                                   boxes=gtboxes_and_label[:, :-1],
+                                                                   labels=gtboxes_and_label[:, -1])
+    if cfgs.ADD_BOX_IN_TENSORBOARD:
+        detections_in_img = show_box_in_tensor.draw_boxes_with_categories_and_scores(img_batch=img_batch,
+                                                                                     boxes=final_bbox,
+                                                                                     labels=final_category,
+                                                                                     scores=final_scores)
+        tf.summary.image('Compare/final_detection', detections_in_img)
+    tf.summary.image('Compare/gtboxes', gtboxes_in_img)
+
+    # ___________________________________________________________________________________________________add summary
+
+    global_step = slim.get_or_create_global_step()
+    lr = tf.train.piecewise_constant(global_step,
+                                     boundaries=[np.int64(cfgs.DECAY_STEP[0]), np.int64(cfgs.DECAY_STEP[1])],
+                                     values=[cfgs.LR, cfgs.LR / 10., cfgs.LR / 100.])
+    tf.summary.scalar('lr', lr)
+    optimizer = tf.train.MomentumOptimizer(lr, momentum=cfgs.MOMENTUM)
+    # optimizer = tf.train.AdamOptimizer(lr)
+
+    # ---------------------------------------------------------------------------------------------compute gradients
+    gradients = faster_rcnn.get_gradients(optimizer, total_loss)
+
+    # enlarge_gradients for bias
+    if cfgs.MUTILPY_BIAS_GRADIENT:
+        gradients = faster_rcnn.enlarge_gradients_for_bias(gradients)
+
+    if cfgs.GRADIENT_CLIPPING_BY_NORM:
+        with tf.name_scope('clip_gradients_YJR'):
+            gradients = slim.learning.clip_gradient_norms(gradients,
+                                                          cfgs.GRADIENT_CLIPPING_BY_NORM)
+    # _____________________________________________________________________________________________compute gradients
+
+
+
+    # train_op
+    train_op = optimizer.apply_gradients(grads_and_vars=gradients,
+                                         global_step=global_step)
+    summary_op = tf.summary.merge_all()
+    init_op = tf.group(
+        tf.global_variables_initializer(),
+        tf.local_variables_initializer()
+    )
+
+    restorer, restore_ckpt = faster_rcnn.get_restorer()
+    saver = tf.train.Saver(max_to_keep=30)
+
+    config = tf.ConfigProto()
+    config.gpu_options.allow_growth = True
+    compute_time = 0
+    compute_imgnum = 0
+
+    with tf.Session(config=config) as sess:
+        sess.run(init_op)
+        if not restorer is None:
+            restorer.restore(sess, restore_ckpt)
+            print('restore model')
+        coord = tf.train.Coordinator()
+        threads = tf.train.start_queue_runners(sess, coord)
+
+        summary_path = os.path.join(cfgs.SUMMARY_PATH, cfgs.VERSION)
+        tools.mkdir(summary_path)
+        summary_writer = tf.summary.FileWriter(summary_path, graph=sess.graph)
+        training_time = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))
+
+        for step in range(cfgs.MAX_ITERATION):
+            training_time1 = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))
+            if step % cfgs.SHOW_TRAIN_INFO_INTE != 0 and step % cfgs.SMRY_ITER != 0:
+                _, global_stepnp = sess.run([train_op, global_step])
+
+            else:
+                if step % cfgs.SHOW_TRAIN_INFO_INTE == 0 and step % cfgs.SMRY_ITER != 0:
+                    start = time.time()
+
+                    _, global_stepnp, img_name, rpnLocLoss, rpnClsLoss, rpnTotalLoss, \
+                    fastrcnnLocLoss, fastrcnnClsLoss, fastrcnnTotalLoss, totalLoss = \
+                        sess.run(
+                            [train_op, global_step, img_name_batch, rpn_location_loss, rpn_cls_loss, rpn_total_loss,
+                             fastrcnn_loc_loss, fastrcnn_cls_loss, fastrcnn_total_loss, total_loss])
+
+                    end = time.time()
+                    compute_time = compute_time + (end - start)
+                    compute_imgnum = compute_imgnum + 1
+                    print(""" {}: step{}    image_name:{} |\t
+                              rpn_loc_loss:{} |\t rpn_cla_loss:{} |\t rpn_total_loss:{} |
+                              fast_rcnn_loc_loss:{} |\t fast_rcnn_cla_loss:{} |\t fast_rcnn_total_loss:{} |
+                              total_loss:{} |\t per_cost_time:{}s""" \
+                          .format(training_time1, global_stepnp, str(img_name[0]), rpnLocLoss, rpnClsLoss,
+                                  rpnTotalLoss, fastrcnnLocLoss, fastrcnnClsLoss, fastrcnnTotalLoss, totalLoss,
+                                  (end - start)))
+                else:
+                    if step % cfgs.SMRY_ITER == 0:
+                        _, global_stepnp, summary_str = sess.run([train_op, global_step, summary_op])
+                        summary_writer.add_summary(summary_str, global_stepnp)
+                        summary_writer.flush()
+
+            if (step > 0 and step % cfgs.SAVE_WEIGHTS_INTE == 0) or (step == cfgs.MAX_ITERATION - 1):
+
+                save_dir = os.path.join(cfgs.TRAINED_CKPT, cfgs.VERSION)
+                if not os.path.exists(save_dir):
+                    os.mkdir(save_dir)
+
+                #save_ckpt = os.path.join(save_dir, 'voc_' + str(global_stepnp) + 'model.ckpt')
+                save_ckpt = os.path.join(save_dir, 'pcb_' + str(global_stepnp) + 'model.ckpt')
+                saver.save(sess, save_ckpt)
+                print(' weights had been saved')
+        print('average_training_time_per_image is' + str(compute_time / compute_imgnum))
+        print('traning start time is ' + training_time)
+        end_training_time = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))
+        print('traning end time is ' + end_training_time)
+        coord.request_stop()
+        coord.join(threads)
+
+
+if __name__ == '__main__':
+
+    train()
+
+
+
+
+
+
+
+
+
+
diff --git a/example-apps/PDD/pcb-defect-detection/tools/train_with_placeholder.py b/example-apps/PDD/pcb-defect-detection/tools/train_with_placeholder.py
new file mode 100755
index 0000000..b329715
--- /dev/null
+++ b/example-apps/PDD/pcb-defect-detection/tools/train_with_placeholder.py
@@ -0,0 +1,233 @@
+# -*- coding:utf-8 -*-
+
+from __future__ import absolute_import
+from __future__ import print_function
+from __future__ import division
+
+import tensorflow as tf
+import tensorflow.contrib.slim as slim
+import os, sys
+sys.path.append("../")
+sys.path.append("../data/lib_coco")
+sys.path.append('../data/lib_coco/PythonAPI/')
+
+import numpy as np
+import time
+
+from libs.configs import cfgs
+from libs.networks import build_whole_network
+from data.io import image_preprocess
+from libs.box_utils import show_box_in_tensor
+from help_utils import tools
+from data.lib_coco.get_coco_next_batch import next_img
+
+
+os.environ["CUDA_VISIBLE_DEVICES"] = cfgs.GPU_GROUP
+
+
+def preprocess_img(img_plac, gtbox_plac):
+    '''
+
+    :param img_plac: [H, W, 3] uint 8 img. In RGB.
+    :param gtbox_plac: shape of [-1, 5]. [xmin, ymin, xmax, ymax, label]
+    :return:
+    '''
+
+    img = tf.cast(img_plac, tf.float32)
+
+    # gtboxes_and_label = tf.cast(gtbox_plac, tf.float32)
+    img, gtboxes_and_label = image_preprocess.short_side_resize(img_tensor=img,
+                                                                gtboxes_and_label=gtbox_plac,
+                                                                target_shortside_len=cfgs.IMG_SHORT_SIDE_LEN,
+                                                                length_limitation=cfgs.IMG_MAX_LENGTH)
+    img, gtboxes_and_label = image_preprocess.random_flip_left_right(img_tensor=img,
+                                                                     gtboxes_and_label=gtboxes_and_label)
+    img = img - tf.constant([[cfgs.PIXEL_MEAN]])
+    img_batch = tf.expand_dims(img, axis=0)
+
+    # gtboxes_and_label = tf.Print(gtboxes_and_label, [tf.shape(gtboxes_and_label)], message='gtbox shape')
+    return img_batch, gtboxes_and_label
+
+def train():
+
+    faster_rcnn = build_whole_network.DetectionNetwork(base_network_name=cfgs.NET_NAME,
+                                                       is_training=True)
+
+    with tf.name_scope('get_batch'):
+        img_plac = tf.placeholder(dtype=tf.uint8, shape=[None, None, 3])
+        gtbox_plac = tf.placeholder(dtype=tf.int32, shape=[None, 5])
+
+        img_batch, gtboxes_and_label = preprocess_img(img_plac, gtbox_plac)
+        # gtboxes_and_label = tf.reshape(gtboxes_and_label_batch, [-1, 5])
+
+    biases_regularizer = tf.no_regularizer
+    weights_regularizer = tf.contrib.layers.l2_regularizer(cfgs.WEIGHT_DECAY)
+
+    # list as many types of layers as possible, even if they are not used now
+    with slim.arg_scope([slim.conv2d, slim.conv2d_in_plane, \
+                         slim.conv2d_transpose, slim.separable_conv2d, slim.fully_connected],
+                        weights_regularizer=weights_regularizer,
+                        biases_regularizer=biases_regularizer,
+                        biases_initializer=tf.constant_initializer(0.0)):
+        final_bbox, final_scores, final_category, loss_dict = faster_rcnn.build_whole_detection_network(
+            input_img_batch=img_batch,
+            gtboxes_batch=gtboxes_and_label)
+
+    # ----------------------------------------------------------------------------------------------------build loss
+    weight_decay_loss = 0 # tf.add_n(slim.losses.get_regularization_losses())
+    rpn_location_loss = loss_dict['rpn_loc_loss']
+    rpn_cls_loss = loss_dict['rpn_cls_loss']
+    rpn_total_loss = rpn_location_loss + rpn_cls_loss
+
+    fastrcnn_cls_loss = loss_dict['fastrcnn_cls_loss']
+    fastrcnn_loc_loss = loss_dict['fastrcnn_loc_loss']
+    fastrcnn_total_loss = fastrcnn_cls_loss + fastrcnn_loc_loss
+
+    total_loss = rpn_total_loss + fastrcnn_total_loss + weight_decay_loss
+    # ____________________________________________________________________________________________________build loss
+
+
+
+    # ---------------------------------------------------------------------------------------------------add summary
+    tf.summary.scalar('RPN_LOSS/cls_loss', rpn_cls_loss)
+    tf.summary.scalar('RPN_LOSS/location_loss', rpn_location_loss)
+    tf.summary.scalar('RPN_LOSS/rpn_total_loss', rpn_total_loss)
+
+    tf.summary.scalar('FAST_LOSS/fastrcnn_cls_loss', fastrcnn_cls_loss)
+    tf.summary.scalar('FAST_LOSS/fastrcnn_location_loss', fastrcnn_loc_loss)
+    tf.summary.scalar('FAST_LOSS/fastrcnn_total_loss', fastrcnn_total_loss)
+
+    tf.summary.scalar('LOSS/total_loss', total_loss)
+    tf.summary.scalar('LOSS/regular_weights', weight_decay_loss)
+
+    gtboxes_in_img = show_box_in_tensor.draw_boxes_with_categories(img_batch=img_batch,
+                                                                   boxes=gtboxes_and_label[:, :-1],
+                                                                   labels=gtboxes_and_label[:, -1])
+    if cfgs.ADD_BOX_IN_TENSORBOARD:
+        detections_in_img = show_box_in_tensor.draw_boxes_with_categories_and_scores(img_batch=img_batch,
+                                                                                     boxes=final_bbox,
+                                                                                     labels=final_category,
+                                                                                     scores=final_scores)
+        tf.summary.image('Compare/final_detection', detections_in_img)
+    tf.summary.image('Compare/gtboxes', gtboxes_in_img)
+
+    # ___________________________________________________________________________________________________add summary
+
+    global_step = slim.get_or_create_global_step()
+    lr = tf.train.piecewise_constant(global_step,
+                                     boundaries=[np.int64(cfgs.DECAY_STEP[0]), np.int64(cfgs.DECAY_STEP[1])],
+                                     values=[cfgs.LR, cfgs.LR / 10., cfgs.LR / 100.])
+    tf.summary.scalar('lr', lr)
+    optimizer = tf.train.MomentumOptimizer(lr, momentum=cfgs.MOMENTUM)
+
+    # ---------------------------------------------------------------------------------------------compute gradients
+    gradients = faster_rcnn.get_gradients(optimizer, total_loss)
+
+    # enlarge_gradients for bias
+    if cfgs.MUTILPY_BIAS_GRADIENT:
+        gradients = faster_rcnn.enlarge_gradients_for_bias(gradients)
+
+    if cfgs.GRADIENT_CLIPPING_BY_NORM:
+        with tf.name_scope('clip_gradients_YJR'):
+            gradients = slim.learning.clip_gradient_norms(gradients,
+                                                          cfgs.GRADIENT_CLIPPING_BY_NORM)
+    # _____________________________________________________________________________________________compute gradients
+
+
+
+    # train_op
+    train_op = optimizer.apply_gradients(grads_and_vars=gradients,
+                                         global_step=global_step)
+    summary_op = tf.summary.merge_all()
+    init_op = tf.group(
+        tf.global_variables_initializer(),
+        tf.local_variables_initializer()
+    )
+
+    restorer, restore_ckpt = faster_rcnn.get_restorer()
+    saver = tf.train.Saver(max_to_keep=30)
+
+    config = tf.ConfigProto()
+    config.gpu_options.allow_growth = True
+
+    with tf.Session(config=config) as sess:
+        sess.run(init_op)
+        if not restorer is None:
+            restorer.restore(sess, restore_ckpt)
+            print('restore model')
+
+        summary_path = os.path.join(cfgs.SUMMARY_PATH, cfgs.VERSION)
+        tools.mkdir(summary_path)
+        summary_writer = tf.summary.FileWriter(summary_path, graph=sess.graph)
+
+        for step in range(cfgs.MAX_ITERATION):
+
+            img_id, img, gt_info = next_img(step=step)
+            training_time = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))
+
+            if step % cfgs.SHOW_TRAIN_INFO_INTE != 0 and step % cfgs.SMRY_ITER != 0:
+                _, global_stepnp = sess.run([train_op, global_step],
+                                            feed_dict={img_plac: img,
+                                                       gtbox_plac: gt_info}
+                                            )
+
+            else:
+                if step % cfgs.SHOW_TRAIN_INFO_INTE == 0 and step % cfgs.SMRY_ITER != 0:
+                    start = time.time()
+
+                    _, global_stepnp, rpnLocLoss, rpnClsLoss, rpnTotalLoss, \
+                    fastrcnnLocLoss, fastrcnnClsLoss, fastrcnnTotalLoss, totalLoss = \
+                        sess.run(
+                            [train_op, global_step, rpn_location_loss, rpn_cls_loss, rpn_total_loss,
+                             fastrcnn_loc_loss, fastrcnn_cls_loss, fastrcnn_total_loss, total_loss],
+                        feed_dict={img_plac: img,
+                                   gtbox_plac: gt_info})
+                    end = time.time()
+                    print(""" {}: step{}    image_name:{} |\t
+                              rpn_loc_loss:{} |\t rpn_cla_loss:{} |\t rpn_total_loss:{} |
+                              fast_rcnn_loc_loss:{} |\t fast_rcnn_cla_loss:{} |\t fast_rcnn_total_loss:{} |
+                              total_loss:{} |\t per_cost_time:{}s""" \
+                          .format(training_time, global_stepnp, str(img_id), rpnLocLoss, rpnClsLoss,
+                                  rpnTotalLoss, fastrcnnLocLoss, fastrcnnClsLoss, fastrcnnTotalLoss, totalLoss,
+                                  (end - start)))
+                else:
+                    if step % cfgs.SMRY_ITER == 0:
+                        _, global_stepnp, summary_str = sess.run([train_op, global_step, summary_op],
+                                                                 feed_dict={img_plac: img,
+                                                                            gtbox_plac: gt_info}
+                                                                 )
+                        summary_writer.add_summary(summary_str, global_stepnp)
+                        summary_writer.flush()
+
+            if (step > 0 and step % cfgs.SAVE_WEIGHTS_INTE == 0) or (step == cfgs.MAX_ITERATION - 1):
+
+                save_dir = os.path.join(cfgs.TRAINED_CKPT, cfgs.VERSION)
+                if not os.path.exists(save_dir):
+                    os.mkdir(save_dir)
+
+                save_ckpt = os.path.join(save_dir, 'voc_' + str(global_stepnp) + 'model.ckpt')
+                saver.save(sess, save_ckpt)
+                print(' weights had been saved')
+
+
+if __name__ == '__main__':
+
+    train()
+
+#
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+