From 485ece233483f97b1d9cf5bbc627c30d74bb9c81 Mon Sep 17 00:00:00 2001 From: yangxue Date: Fri, 24 May 2019 18:46:22 +0800 Subject: [PATCH] add core code --- README.md | 4 +- data/__init__.py | 0 data/io/__init__.py | 0 data/io/convert_data_to_tfrecord.py | 122 + data/io/convert_data_to_tfrecord_coco.py | 103 + data/io/convert_data_to_tfrecord_voc2012.py | 141 + data/io/image_preprocess.py | 79 + data/io/image_preprocess_multi_gpu.py | 83 + data/io/read_tfrecord.py | 102 + data/io/read_tfrecord_multi_gpu.py | 148 + data/lib_coco/PythonAPI/Makefile | 9 + data/lib_coco/PythonAPI/__init__.py | 0 data/lib_coco/PythonAPI/pycocoDemo.ipynb | 272 + data/lib_coco/PythonAPI/pycocoEvalDemo.ipynb | 168 + .../PythonAPI/pycocotools/__init__.py | 1 + data/lib_coco/PythonAPI/pycocotools/_mask.c | 16137 ++++++++++++++++ data/lib_coco/PythonAPI/pycocotools/_mask.pyx | 308 + data/lib_coco/PythonAPI/pycocotools/coco.py | 433 + .../PythonAPI/pycocotools/cocoeval.py | 534 + data/lib_coco/PythonAPI/pycocotools/mask.py | 103 + data/lib_coco/PythonAPI/setup.py | 27 + data/lib_coco/__init__.py | 0 data/lib_coco/common/gason.cpp | 335 + data/lib_coco/common/gason.h | 136 + data/lib_coco/common/maskApi.c | 230 + data/lib_coco/common/maskApi.h | 60 + data/lib_coco/get_coco_next_batch.py | 73 + data/pretrained_weights/README.md | 2 + help_utils/__init__.py | 0 help_utils/tools.py | 19 + libs/__init__.py | 0 libs/box_utils/__init__.py | 0 libs/box_utils/anchor_utils.py | 92 + libs/box_utils/bbox_transform.py | 66 + libs/box_utils/boxes_utils.py | 111 + libs/box_utils/cython_utils/Makefile | 6 + libs/box_utils/cython_utils/__init__.py | 0 libs/box_utils/cython_utils/bbox.c | 11128 +++++++++++ libs/box_utils/cython_utils/bbox.pyx | 249 + libs/box_utils/cython_utils/nms.c | 9561 +++++++++ libs/box_utils/cython_utils/nms.pyx | 123 + libs/box_utils/cython_utils/setup.py | 133 + libs/box_utils/draw_box_in_img.py | 162 + libs/box_utils/generate_anchors.py | 148 + libs/box_utils/show_box_in_tensor.py | 70 + libs/box_utils/tf_ops.py | 39 + libs/configs/__init__.py | 0 libs/configs/cfgs.py | 116 + libs/configs/cfgs_res50_coco_1x_v1.py | 104 + libs/configs/cfgs_res50_coco_1x_v2.py | 98 + libs/configs/cfgs_res50_coco_1x_v3.py | 97 + libs/configs/cfgs_res50_voc0712_v1.py | 115 + libs/configs/cfgs_res50_voc0712_v2.py | 116 + libs/configs/cfgs_res50_voc0712_v3.py | 116 + libs/configs/cfgs_res50_voc07_v1.py | 115 + libs/configs/cfgs_res50_voc07_v2.py | 115 + libs/configs/cfgs_res50_voc07_v3.py | 115 + libs/configs/cfgs_res50_voc07_v4.py | 115 + libs/detection_oprations/__init__.py | 0 .../anchor_target_layer_without_boxweight.py | 63 + libs/detection_oprations/proposal_opr.py | 67 + libs/label_name_dict/__init__.py | 0 libs/label_name_dict/coco_dict.py | 54 + libs/label_name_dict/label_dict.py | 135 + libs/losses/__init__.py | 0 libs/losses/losses.py | 124 + libs/networks/__init__.py | 0 libs/networks/build_whole_network.py | 353 + libs/networks/mobilenet/README.md | 12 + libs/networks/mobilenet/__init__.py | 0 libs/networks/mobilenet/conv_blocks.py | 352 + libs/networks/mobilenet/mobilenet.py | 433 + libs/networks/mobilenet/mobilenet_v2.py | 188 + libs/networks/mobilenet/mobilenet_v2_test.py | 176 + libs/networks/mobilenet_v2.py | 127 + libs/networks/resnet.py | 202 + libs/networks/resnet_gluoncv.py | 266 + libs/networks/slim_nets/__init__.py | 1 + libs/networks/slim_nets/alexnet.py | 125 + libs/networks/slim_nets/alexnet_test.py | 145 + libs/networks/slim_nets/cifarnet.py | 112 + libs/networks/slim_nets/inception.py | 37 + .../networks/slim_nets/inception_resnet_v2.py | 359 + .../slim_nets/inception_resnet_v2_test.py | 265 + libs/networks/slim_nets/inception_utils.py | 71 + libs/networks/slim_nets/inception_v1.py | 305 + libs/networks/slim_nets/inception_v1_test.py | 210 + libs/networks/slim_nets/inception_v2.py | 520 + libs/networks/slim_nets/inception_v2_test.py | 262 + libs/networks/slim_nets/inception_v3.py | 560 + libs/networks/slim_nets/inception_v3_test.py | 292 + libs/networks/slim_nets/inception_v4.py | 323 + libs/networks/slim_nets/inception_v4_test.py | 216 + libs/networks/slim_nets/lenet.py | 93 + libs/networks/slim_nets/mobilenet_v1.md | 47 + libs/networks/slim_nets/mobilenet_v1.png | Bin 0 -> 100916 bytes libs/networks/slim_nets/mobilenet_v1.py | 397 + libs/networks/slim_nets/mobilenet_v1_test.py | 450 + libs/networks/slim_nets/nets_factory.py | 112 + libs/networks/slim_nets/nets_factory_test.py | 61 + libs/networks/slim_nets/overfeat.py | 118 + libs/networks/slim_nets/overfeat_test.py | 145 + libs/networks/slim_nets/resnet_utils.py | 244 + libs/networks/slim_nets/resnet_v1.py | 329 + libs/networks/slim_nets/resnet_v1_test.py | 440 + libs/networks/slim_nets/resnet_v2.py | 333 + libs/networks/slim_nets/resnet_v2_test.py | 443 + libs/networks/slim_nets/vgg.py | 265 + libs/networks/slim_nets/vgg_test.py | 455 + libs/networks/test_images/000013.jpg | Bin 0 -> 133840 bytes libs/networks/test_images/000018.jpg | Bin 0 -> 52801 bytes libs/networks/test_images/000031.jpg | Bin 0 -> 110380 bytes libs/networks/test_images/000038.jpg | Bin 0 -> 70116 bytes libs/networks/test_images/000045.jpg | Bin 0 -> 43692 bytes libs/networks/xception.bak.py | 219 + libs/networks/xception.py | 265 + libs/setup.py | 225 + libs/val_libs/__init__.py | 0 libs/val_libs/voc_eval.py | 263 + output/trained_weights/README.md | 1 + tools/__init__.py | 0 tools/demos/000058.jpg | Bin 0 -> 129047 bytes tools/demos/000108.jpg | Bin 0 -> 75282 bytes tools/demos/000237.jpg | Bin 0 -> 110637 bytes tools/demos/000449.jpg | Bin 0 -> 88727 bytes tools/demos/000611.jpg | Bin 0 -> 94677 bytes tools/demos/000706.jpg | Bin 0 -> 31410 bytes tools/demos/000719.jpg | Bin 0 -> 108797 bytes tools/demos/004640.jpg | Bin 0 -> 119476 bytes tools/eval.py | 197 + tools/eval_coco.py | 222 + tools/eval_coco_multiprocessing.py | 233 + tools/inference.py | 151 + tools/inference_for_coco.py | 189 + tools/inference_results/000058.jpg | Bin 0 -> 226900 bytes tools/inference_results/000108.jpg | Bin 0 -> 140913 bytes tools/inference_results/000237.jpg | Bin 0 -> 212381 bytes tools/inference_results/000449.jpg | Bin 0 -> 160020 bytes tools/inference_results/000611.jpg | Bin 0 -> 199878 bytes tools/inference_results/000706.jpg | Bin 0 -> 78045 bytes tools/inference_results/000719.jpg | Bin 0 -> 242658 bytes tools/inference_results/004640.jpg | Bin 0 -> 221240 bytes tools/multi_gpu_train.py | 346 + tools/test.py | 165 + tools/test_coco.py | 215 + tools/test_coco_multiprocessing.py | 209 + tools/train.py | 172 + tools/train_with_placeholder.py | 231 + 148 files changed, 56328 insertions(+), 1 deletion(-) create mode 100644 data/__init__.py create mode 100644 data/io/__init__.py create mode 100644 data/io/convert_data_to_tfrecord.py create mode 100644 data/io/convert_data_to_tfrecord_coco.py create mode 100644 data/io/convert_data_to_tfrecord_voc2012.py create mode 100644 data/io/image_preprocess.py create mode 100644 data/io/image_preprocess_multi_gpu.py create mode 100644 data/io/read_tfrecord.py create mode 100644 data/io/read_tfrecord_multi_gpu.py create mode 100644 data/lib_coco/PythonAPI/Makefile create mode 100644 data/lib_coco/PythonAPI/__init__.py create mode 100644 data/lib_coco/PythonAPI/pycocoDemo.ipynb create mode 100644 data/lib_coco/PythonAPI/pycocoEvalDemo.ipynb create mode 100644 data/lib_coco/PythonAPI/pycocotools/__init__.py create mode 100644 data/lib_coco/PythonAPI/pycocotools/_mask.c create mode 100644 data/lib_coco/PythonAPI/pycocotools/_mask.pyx create mode 100644 data/lib_coco/PythonAPI/pycocotools/coco.py create mode 100644 data/lib_coco/PythonAPI/pycocotools/cocoeval.py create mode 100644 data/lib_coco/PythonAPI/pycocotools/mask.py create mode 100644 data/lib_coco/PythonAPI/setup.py create mode 100644 data/lib_coco/__init__.py create mode 100644 data/lib_coco/common/gason.cpp create mode 100644 data/lib_coco/common/gason.h create mode 100644 data/lib_coco/common/maskApi.c create mode 100644 data/lib_coco/common/maskApi.h create mode 100644 data/lib_coco/get_coco_next_batch.py create mode 100644 data/pretrained_weights/README.md create mode 100644 help_utils/__init__.py create mode 100644 help_utils/tools.py create mode 100644 libs/__init__.py create mode 100644 libs/box_utils/__init__.py create mode 100644 libs/box_utils/anchor_utils.py create mode 100644 libs/box_utils/bbox_transform.py create mode 100644 libs/box_utils/boxes_utils.py create mode 100644 libs/box_utils/cython_utils/Makefile create mode 100644 libs/box_utils/cython_utils/__init__.py create mode 100644 libs/box_utils/cython_utils/bbox.c create mode 100644 libs/box_utils/cython_utils/bbox.pyx create mode 100644 libs/box_utils/cython_utils/nms.c create mode 100644 libs/box_utils/cython_utils/nms.pyx create mode 100644 libs/box_utils/cython_utils/setup.py create mode 100644 libs/box_utils/draw_box_in_img.py create mode 100755 libs/box_utils/generate_anchors.py create mode 100644 libs/box_utils/show_box_in_tensor.py create mode 100644 libs/box_utils/tf_ops.py create mode 100644 libs/configs/__init__.py create mode 100644 libs/configs/cfgs.py create mode 100644 libs/configs/cfgs_res50_coco_1x_v1.py create mode 100644 libs/configs/cfgs_res50_coco_1x_v2.py create mode 100644 libs/configs/cfgs_res50_coco_1x_v3.py create mode 100644 libs/configs/cfgs_res50_voc0712_v1.py create mode 100644 libs/configs/cfgs_res50_voc0712_v2.py create mode 100644 libs/configs/cfgs_res50_voc0712_v3.py create mode 100644 libs/configs/cfgs_res50_voc07_v1.py create mode 100644 libs/configs/cfgs_res50_voc07_v2.py create mode 100644 libs/configs/cfgs_res50_voc07_v3.py create mode 100644 libs/configs/cfgs_res50_voc07_v4.py create mode 100644 libs/detection_oprations/__init__.py create mode 100644 libs/detection_oprations/anchor_target_layer_without_boxweight.py create mode 100644 libs/detection_oprations/proposal_opr.py create mode 100644 libs/label_name_dict/__init__.py create mode 100644 libs/label_name_dict/coco_dict.py create mode 100644 libs/label_name_dict/label_dict.py create mode 100644 libs/losses/__init__.py create mode 100644 libs/losses/losses.py create mode 100644 libs/networks/__init__.py create mode 100644 libs/networks/build_whole_network.py create mode 100644 libs/networks/mobilenet/README.md create mode 100644 libs/networks/mobilenet/__init__.py create mode 100644 libs/networks/mobilenet/conv_blocks.py create mode 100644 libs/networks/mobilenet/mobilenet.py create mode 100644 libs/networks/mobilenet/mobilenet_v2.py create mode 100644 libs/networks/mobilenet/mobilenet_v2_test.py create mode 100644 libs/networks/mobilenet_v2.py create mode 100644 libs/networks/resnet.py create mode 100644 libs/networks/resnet_gluoncv.py create mode 100644 libs/networks/slim_nets/__init__.py create mode 100644 libs/networks/slim_nets/alexnet.py create mode 100644 libs/networks/slim_nets/alexnet_test.py create mode 100644 libs/networks/slim_nets/cifarnet.py create mode 100644 libs/networks/slim_nets/inception.py create mode 100644 libs/networks/slim_nets/inception_resnet_v2.py create mode 100644 libs/networks/slim_nets/inception_resnet_v2_test.py create mode 100644 libs/networks/slim_nets/inception_utils.py create mode 100644 libs/networks/slim_nets/inception_v1.py create mode 100644 libs/networks/slim_nets/inception_v1_test.py create mode 100644 libs/networks/slim_nets/inception_v2.py create mode 100644 libs/networks/slim_nets/inception_v2_test.py create mode 100644 libs/networks/slim_nets/inception_v3.py create mode 100644 libs/networks/slim_nets/inception_v3_test.py create mode 100644 libs/networks/slim_nets/inception_v4.py create mode 100644 libs/networks/slim_nets/inception_v4_test.py create mode 100644 libs/networks/slim_nets/lenet.py create mode 100644 libs/networks/slim_nets/mobilenet_v1.md create mode 100644 libs/networks/slim_nets/mobilenet_v1.png create mode 100644 libs/networks/slim_nets/mobilenet_v1.py create mode 100644 libs/networks/slim_nets/mobilenet_v1_test.py create mode 100644 libs/networks/slim_nets/nets_factory.py create mode 100644 libs/networks/slim_nets/nets_factory_test.py create mode 100644 libs/networks/slim_nets/overfeat.py create mode 100644 libs/networks/slim_nets/overfeat_test.py create mode 100644 libs/networks/slim_nets/resnet_utils.py create mode 100644 libs/networks/slim_nets/resnet_v1.py create mode 100644 libs/networks/slim_nets/resnet_v1_test.py create mode 100644 libs/networks/slim_nets/resnet_v2.py create mode 100644 libs/networks/slim_nets/resnet_v2_test.py create mode 100644 libs/networks/slim_nets/vgg.py create mode 100644 libs/networks/slim_nets/vgg_test.py create mode 100644 libs/networks/test_images/000013.jpg create mode 100644 libs/networks/test_images/000018.jpg create mode 100644 libs/networks/test_images/000031.jpg create mode 100644 libs/networks/test_images/000038.jpg create mode 100644 libs/networks/test_images/000045.jpg create mode 100644 libs/networks/xception.bak.py create mode 100644 libs/networks/xception.py create mode 100644 libs/setup.py create mode 100644 libs/val_libs/__init__.py create mode 100644 libs/val_libs/voc_eval.py create mode 100644 output/trained_weights/README.md create mode 100644 tools/__init__.py create mode 100644 tools/demos/000058.jpg create mode 100644 tools/demos/000108.jpg create mode 100644 tools/demos/000237.jpg create mode 100644 tools/demos/000449.jpg create mode 100644 tools/demos/000611.jpg create mode 100644 tools/demos/000706.jpg create mode 100644 tools/demos/000719.jpg create mode 100644 tools/demos/004640.jpg create mode 100644 tools/eval.py create mode 100644 tools/eval_coco.py create mode 100644 tools/eval_coco_multiprocessing.py create mode 100644 tools/inference.py create mode 100644 tools/inference_for_coco.py create mode 100644 tools/inference_results/000058.jpg create mode 100644 tools/inference_results/000108.jpg create mode 100644 tools/inference_results/000237.jpg create mode 100644 tools/inference_results/000449.jpg create mode 100644 tools/inference_results/000611.jpg create mode 100644 tools/inference_results/000706.jpg create mode 100644 tools/inference_results/000719.jpg create mode 100644 tools/inference_results/004640.jpg create mode 100644 tools/multi_gpu_train.py create mode 100644 tools/test.py create mode 100644 tools/test_coco.py create mode 100644 tools/test_coco_multiprocessing.py create mode 100644 tools/train.py create mode 100644 tools/train_with_placeholder.py diff --git a/README.md b/README.md index 613de0b..9063e25 100644 --- a/README.md +++ b/README.md @@ -13,6 +13,8 @@ This is a tensorflow re-implementation of [Focal Loss for Dense Object Detection | RetinaNet | ResNet50_v1 600 | VOC07 trainval | VOC07 test | 73.16 | - | 8X GeForce RTX 2080 Ti | 1 | | RetinaNet | ResNet50_v1d 600 | VOC07 trainval | VOC07 test | 73.26 | - | 8X GeForce RTX 2080 Ti | 1 | | RetinaNet | ResNet50_v1d 600 | VOC07+12 trainval | VOC07 test | 79.66 | - | 8X GeForce RTX 2080 Ti | 1 | +| RetinaNet | ResNet101_v1d 600 | VOC07+12 trainval | VOC07 test | 81.05 | - | 8X GeForce RTX 2080 Ti | 1 | +| RetinaNet | ResNet101_v1d 800 | VOC07+12 trainval | VOC07 test | 80.69 | - | 8X GeForce RTX 2080 Ti | 1 | | RetinaNet | ResNet50_v1 600 | COCO train2017 | COCO val2017 (coco minival) | | 1x | 8X GeForce RTX 2080 Ti | 1 | ## My Development Environment @@ -88,5 +90,5 @@ tensorboard --logdir=. ## Reference 1、https://github.com/endernewton/tf-faster-rcnn 2、https://github.com/zengarden/light_head_rcnn -3、https://github.com/tensorflow/models/tree/master/research/object_detection +3、https://github.com/tensorflow/models/tree/master/research/object_detection 4、https://github.com/fizyr/keras-retinanet diff --git a/data/__init__.py b/data/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/data/io/__init__.py b/data/io/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/data/io/convert_data_to_tfrecord.py b/data/io/convert_data_to_tfrecord.py new file mode 100644 index 0000000..afdf6f7 --- /dev/null +++ b/data/io/convert_data_to_tfrecord.py @@ -0,0 +1,122 @@ +# -*- 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', '/data/code/VOC2007/VOCdevkit/VOC2007/', 'Voc dir') +tf.app.flags.DEFINE_string('xml_dir', 'Annotations', 'xml dir') +tf.app.flags.DEFINE_string('image_dir', 'JPEGImages', 'image dir') +tf.app.flags.DEFINE_string('save_name', 'train', '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', 'pascal', '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), + '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/data/io/convert_data_to_tfrecord_coco.py b/data/io/convert_data_to_tfrecord_coco.py new file mode 100644 index 0000000..205feef --- /dev/null +++ b/data/io/convert_data_to_tfrecord_coco.py @@ -0,0 +1,103 @@ +# -*- 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 +import json +from libs.label_name_dict.label_dict import * +from help_utils.tools import * + +tf.app.flags.DEFINE_string('coco_dir', '/data/COCO/coco_trainvalmini.odgt', 'coco dir') +tf.app.flags.DEFINE_string('save_name', 'train', 'save name') +tf.app.flags.DEFINE_string('save_dir', '../tfrecord/', 'save name') +tf.app.flags.DEFINE_string('dataset', 'coco', '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 convert_pascal_to_tfrecord(coco_trainvalmini): + 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) + + with open(coco_trainvalmini) as f: + files = f.readlines() + + img_count = 0 + gt_count = 0 + + for count, raw_line in enumerate(files): + file = json.loads(raw_line) + img_path = os.path.join('/data/COCO/train2017', file['fpath'].split('_')[-1]) + img_name = file['ID'] + + if not os.path.exists(img_path): + # print('{} is not exist!'.format(img_path)) + img_count += 1 + continue + # img = np.array(Image.open(img_path)) + img = cv2.imread(img_path)[:, :, ::-1] + + if img is None: + continue + + gtboxes = file['gtboxes'] + img_height = file['height'] + img_width = file['width'] + + if len(gtboxes) == 0: + # print('{}: gt is not exist!'.format(img_path)) + gt_count += 1 + continue + + gtbox_label = [] + for gt in gtboxes: + box = gt['box'] + label = gt['tag'] + gtbox_label.append([box[0], box[1], box[0]+box[2], box[1]+box[3], NAME_LABEL_MAP[label]]) + + gtbox_label = np.array(gtbox_label, np.int32) + + feature = tf.train.Features(feature={ + # do not need encode() in linux + 'img_name': _bytes_feature(img_name.encode()), + # 'img_name': _bytes_feature(img_name), + '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(files)) + + print('{} images not exist!'.format(img_count)) + print('{} gts not exist!'.format(gt_count)) + print('\nConversion is complete!') + + +if __name__ == '__main__': + # xml_path = '../data/dataset/VOCdevkit/VOC2007/Annotations/000005.xml' + # read_xml_gtbox_and_label(xml_path) + + # coco_path = '/unsullied/sharefs/_research_detection/GeneralDetection/COCO/data/MSCOCO/odformat/coco_trainvalmini.odgt' + # convert_pascal_to_tfrecord(coco_path) + convert_pascal_to_tfrecord(FLAGS.coco_dir) diff --git a/data/io/convert_data_to_tfrecord_voc2012.py b/data/io/convert_data_to_tfrecord_voc2012.py new file mode 100644 index 0000000..e8bf49e --- /dev/null +++ b/data/io/convert_data_to_tfrecord_voc2012.py @@ -0,0 +1,141 @@ +# -*- 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 tqdm import tqdm + +from libs.label_name_dict.label_dict import * +from help_utils.tools import * + +tf.app.flags.DEFINE_string('VOC_dir', '/data/VOC2012/VOCdevkit/VOC2012/', 'Voc dir') +tf.app.flags.DEFINE_string('xml_dir', 'Annotations', 'xml dir') +tf.app.flags.DEFINE_string('image_dir', 'JPEGImages', 'image dir') +tf.app.flags.DEFINE_string('save_name', 'train2012', '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', 'pascal', '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, 5], + and has [xmin, ymin, xmax, ymax, 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 = [0, 0, 0, 0] + for node in child_item: + if node.tag == 'xmin': + tmp_box[0] = int(node.text) + if node.tag == 'ymin': + tmp_box[1] = int(node.text) + if node.tag == 'xmax': + tmp_box[2] = int(node.text) + if node.tag == 'ymax': + tmp_box[3] = 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) + + fr = open('/data/VOC2012/VOCdevkit/VOC2012/ImageSets/Main/trainval.txt', 'r') + lines = fr.readlines() + + real_cnt = 0 + + pbar = tqdm(glob.glob(xml_path + '/*.xml')) + for xml in pbar: + xml = xml.replace('\\', '/') + tmp = xml.split('/')[-1].split('.')[0] + "\n" + if tmp not in lines: + continue + + 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), + '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()) + real_cnt += 1 + + pbar.set_description("Conversion progress") + + print('\nConversion is complete! {} images.'.format(real_cnt)) + + +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/data/io/image_preprocess.py b/data/io/image_preprocess.py new file mode 100644 index 0000000..3e48ddb --- /dev/null +++ b/data/io/image_preprocess.py @@ -0,0 +1,79 @@ +# -*- 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): + 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/data/io/image_preprocess_multi_gpu.py b/data/io/image_preprocess_multi_gpu.py new file mode 100644 index 0000000..fa25f39 --- /dev/null +++ b/data/io/image_preprocess_multi_gpu.py @@ -0,0 +1,83 @@ +# -*- 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)), new_h, new_w + + +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/data/io/read_tfrecord.py b/data/io/read_tfrecord.py new file mode 100644 index 0000000..f048bbe --- /dev/null +++ b/data/io/read_tfrecord.py @@ -0,0 +1,102 @@ +# -*- 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) + if cfgs.NET_NAME in ['resnet152_v1d', 'resnet101_v1d', 'resnet50_v1d']: + img = img / 255 - tf.constant([[cfgs.PIXEL_MEAN_]]) + else: + 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']: + 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/data/io/read_tfrecord_multi_gpu.py b/data/io/read_tfrecord_multi_gpu.py new file mode 100644 index 0000000..86088be --- /dev/null +++ b/data/io/read_tfrecord_multi_gpu.py @@ -0,0 +1,148 @@ +# -*- coding: utf-8 -*- + +from __future__ import absolute_import +from __future__ import print_function +from __future__ import division + +import tensorflow as tf +import os +import sys +sys.path.append('../../') + +from data.io import image_preprocess_multi_gpu as 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, img_h, img_w = 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, img_h, img_w = 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) + if cfgs.NET_NAME in ['resnet152_v1d', 'resnet101_v1d', 'resnet50_v1d']: + img = img / 255 - tf.constant([[cfgs.PIXEL_MEAN_]]) + else: + img = img - tf.constant([[cfgs.PIXEL_MEAN]]) # sub pixel mean at last + return img_name, img, gtboxes_and_label, num_objects, img_h, img_w + + +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', 'bdd100k', 'DOTA']: + 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) + + # shortside_len = tf.constant(shortside_len) + # shortside_len = tf.random_shuffle(shortside_len)[0] + + img_name, img, gtboxes_and_label, num_obs, img_h, img_w = 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, img_h_batch, img_w_batch = \ + tf.train.batch( + [img_name, img, gtboxes_and_label, num_obs, img_h, img_w], + batch_size=batch_size, + capacity=16, + num_threads=16, + dynamic_pad=True) + + return img_name_batch, img_batch, gtboxes_and_label_batch, num_obs_batch, img_h_batch, img_w_batch + + +if __name__ == '__main__': + os.environ["CUDA_VISIBLE_DEVICES"] = '0,1' + num_gpu = len(cfgs.GPU_GROUP.strip().split(',')) + img_name_batch, img_batch, gtboxes_and_label_batch, num_objects_batch, img_h_batch, img_w_batch = \ + next_batch(dataset_name=cfgs.DATASET_NAME, # 'pascal', 'coco' + batch_size=cfgs.BATCH_SIZE * 8, + shortside_len=cfgs.IMG_SHORT_SIDE_LEN, + is_training=True) + gtboxes_and_label = tf.reshape(gtboxes_and_label_batch, [-1, 5]) + + init_op = tf.group( + tf.global_variables_initializer(), + tf.local_variables_initializer() + ) + + config = tf.ConfigProto() + config.gpu_options.allow_growth = True + + with tf.Session(config=config) as sess: + sess.run(init_op) + + coord = tf.train.Coordinator() + threads = tf.train.start_queue_runners(sess, coord) + + img_name_batch_, img_batch_, gtboxes_and_label_batch_, num_objects_batch_, img_h_batch_, img_w_batch_ \ + = sess.run([img_name_batch, img_batch, gtboxes_and_label_batch, num_objects_batch, img_h_batch, img_w_batch]) + + print(img_name_batch_.shape) + print(img_batch_.shape) + print(gtboxes_and_label_batch_.shape) + print(num_objects_batch_.shape) + print(img_h_batch_.shape) + print('debug') + + coord.request_stop() + coord.join(threads) diff --git a/data/lib_coco/PythonAPI/Makefile b/data/lib_coco/PythonAPI/Makefile new file mode 100644 index 0000000..b0ac458 --- /dev/null +++ b/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/data/lib_coco/PythonAPI/__init__.py b/data/lib_coco/PythonAPI/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/data/lib_coco/PythonAPI/pycocoDemo.ipynb b/data/lib_coco/PythonAPI/pycocoDemo.ipynb new file mode 100644 index 0000000..e7b6fdd --- /dev/null +++ b/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": [ + "" + ] + }, + "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\nAAALEgAACxIB0t1+/AAAIABJREFUeJzsvXmUHNd93/u5t6p6n31fgMFgB7GDIMB9k0RRKy1FuxRF\nSuIlkt97SezYVpKX0E7i46enZ1t+ii3Hsi3bkixL1EJR3ERS3EESxEIAJNbBzACYfemZnum9qu59\nf9yq7p7BgJaP3zkRc+Z3Tp3urq66det3b/2W7+93fyW01qzSKq3SKq3SKq3SW4vk/+wOrNIqrdIq\nrdIqrdI/nFYV+Cqt0iqt0iqt0luQVhX4Kq3SKq3SKq3SW5BWFfgqrdIqrdIqrdJbkFYV+Cqt0iqt\n0iqt0luQVhX4Kq3SKq3SKq3SW5BWFfgqrdIqrdIqrdJbkFYV+Cqt0iqt0iqt0luQVhX4Kq3SKq3S\nKq3SW5BWFfgqrdIqrdIqrdJbkOz/2R0AOJ9BFwpFJibGaGlqJR5PorWPkJqIZSEtiDo2vldGKYVl\nOXi+wHXdShtCiCWfWoGQYAmQlkILjdBgI7CFxLIsLKmQQl91rtQ17WiN1tVjNB6WZeG6Lo7jYNs2\nSnkIIfA8858QAt/3UUphS8t0UApE0K7WGoVGCbC1wNeqci0fgVYStETjV/ugzHm1VOmvdTUPao8t\nlUokEolK/8J7qm1HCLBltY3lpFS1j0opVGD7hc3UtqfVsrEI/lNKBdcyW8grpUDpctAvBQTniZB1\ndqXPvgaFhYfAVxLf96vXDcZJB9fSykMj8dFoBCDRUqC1QAh9Fa+0DvutATMGZoeq3o8WSOWhBUis\npfctwKfan+V0Ld4u599KvLv2+RIZzB+JQGgftEJKsIQ0Y6rN2IIG7VfaFNJe0qZWaoV5IdDar/Bl\neb8kAillZV/t/9eajyuVb9YCUNUxCY/T4upnMbxvrQXBrVfnGObT16JyvNY6mK2q0l8hqv1W2sey\nrMq1Pc88z8rXlWe9XDbzM5FI4CkfLUVlPvu+jxACRzrmvpVEGG6be5eKxfwiwhI4dgRRKOM4NvFY\nhB898ACnTp3i3ve/m4sXh9i+cweJRILS4gJf/OIX+YWPfJTb7no7Lz39BA/+8Lu88563MzU1RSza\nTn//eiynxLHjL/P6sTNIDz728Q9y+txrLOZz3LDjVh77yaPEE1GmZ6e4btdOnGgSRIQ9ew/yzDM/\n5eMf+whr1vTwJ1/9Cjt27GBmOo20LW666WbODlxkLrPIts3bSNbV40lJvljCEpKJqUnW9PXheiVm\nJsbZu3M7Nprc4gINKYe/+tpf8/zRo3z1j/8UWSzx/AvP8PILz7JYzvLBj36SxuZ25scnOHf6NRp7\n+1EiRn5hjr6eLpyIxZNPPU1f/0Y+8YlP8IO/+XP+4i+/RmdvH+9417tZv2ETMzOztHd2k0g24PoK\nOxbDkj5tTfV8+y/+hD/+0hf5T7/zXxhNL/KnX/tzPvmxTxKzHN79gfdy5fIoD/7gQQ7edhsb1/eR\nSjbxO5/7EH59jD/4i4dINaxnemKSpx77Ni+/8Di7tu/i1eNnueNt7+SmgzdjWVAuLdDU2MLpc2fp\n6+snly0ws7BI34aNxGMpPN+lubmRRCLF7Eway7KIRqNkFzKs6+rgtcOv8E8+dB9Fd+HaQuFnIOv+\n++//x5z//wtdXnDvtyNRWtuamJ1N01BfTyRioZTC90rEIg5oH8eS2JZEeT5aC6K2jWNZOJZFxLZw\nLFHZLEcQkQJLaixLIC2BY0ksKbClQKCxhNkvpQge6OAzUGhah4Kbyv+2beH75oH3PA+tNbbtALoi\nqLTWSCnNJgJhIYywkEGDQgbXQVQedCOoAptKG2WBCIVWVfEtEeRCrbwfo/hc1yMej1Eul4P+WEbw\nabXkePNf0OQ1FE2tQBZGshIq26WCfem+mh5V+FT7n1LGoNEow49AcKMlaIEWEqWNglFaowLeKKUR\naKQQSIHhpwQpMPuDe5JCYgkBwvRACiPQJcFxgNAaoRUCFXwP2gtUv9kfzBtCRQMS0weNNmNVM5bL\nt5VIahBIEKx8rDRz5NrKX6Ar/Qw+BYbPld8KS8hgXksznzUIIZESpBSgFVqH81wGGjVUQ9X7rYx/\nuC0b56sM6WXGYkhVoyn4X1CxBpecUzEijOFo/hMV5V2rpLXWqPATVbEAtQ7GpcKPapsimBfLlbEx\nms01bdumWCxSLBaJRCJozNxQwRxTSmGLYG5rYfhoQalUxLING7WvyOaypJIpJq6MEIvFmJudQ2g4\nevwosWiMmw7eyMWLF/E9j3x2kZ6eHi4OD7Nn3z6E6/Ltb32HO26/h1isgXe+5/1EokkikQhtrWuZ\nnZnm2PEjbNqyhbn5eaLxBPFIkmx2loamFBMTI2hdpqG+jt27drJp00Zy2SJ/9rX/wU033cjmLZv4\nr//1d9h3/R66Ojt55pmfMjUzQ0dbJ76rSKQamcsXSTU20djSzsJinvqGBk6eOIElJN1dXUxNTjE3\nl2YunWb9+o2s37yFb33zW6xbs4br9+3lxw89yOzcPMdPvM7BAwdpb2lhamKUS2NTNDa109e3jtHx\nCabnM9z6trtpbO/EdTUR4bBr0w62bt/J1//mb/BUkb17dnDk1Ze5+c7b6Vm/hsVckYamJhYWcuiy\nx+EXX2Df/n28cvhVko2tfPaTn+C5p59k69ZNHDl6hDvvuJud+/Zy7OwF6prbuHT6GKPpGW66617m\nFwq0tLewdWsfUxOXee6Z5/jCf/jPrN+4GSkks3OzNDXVc/KNN9i1dy9da3pJNTSwWCjS2NxIxIlR\nX1+HWyxiS0kkFiU9Pw+2RV3cIiLgD/7v3+PKlWF+4wv/7rev8WD/TPRzAaHXxR2EX8Yrlli7povR\nK0OUSzkSMYeIBZbURB2JVmVsfOIRi5gjiEZkZXNscGwRbJqYLXFsHZyvcIQR3JbQoAJhLY2wE1IH\n31cWlLUCSylVsdwjkQi+75PP51HqakEmpVEcdmDxW6HHjBGgEOhoYQXnysq55ouq6YRa8l8o0EIK\nvdeKh6wUnl8mErXxPI9SqYTnefjKW+rZryA0awXiVbyoEfLX4tXSPlXbFEYrgjTCz9cK1/dw/TKe\n0igffAVKC/Ndg0LgKfC1Nl53jWdllLCqbAiDqEihsS2BbQkcW1a2iC2I2IKoLYhYrLg5UiODdoRW\nQLgBqGDczLUMHxVa+5XvbzZ/ViIlQNWOcw3plU+5Ji3xnmuHTsuq1y10xQuVaGOAaBV472rJeVpr\nlG/QiGsp5Frv+s0Qhjfrr9Ya7SuWK2MdGFKWqHr4SxW56ZtSXLV/OWK1fG6H9xkq7vD78vvTWlMq\nlXAch1wuV/HUayncZ871UbpMqVQgnZ7B81181yPqRJifToPrM5vJMDIxQTSVoH/TZj77z3+JZ59+\njsmJCaK2Q1NDHRMTE7S0tXLx4kUGBwc5f/4cO3fvZPeefdQ3tFIsF8hkMlwaHuHylRl2793H5q0b\neO65Z7g4OIwUFuMTU5S0z449u9l03SYOH3uF4UsXGB0Z4ve/9LsI32P39uv4yv/7RxTzOQ7ecIBj\nR45iCfBdj4bmJlq7uvCFTSxRR31DC4WST7nkUcgVyS/kKC3kuX7P9aTTGc5fGETaMRZzZSbTCzQ2\nNHPwphv5w6/8Ef/hP/9HGlqb2bpxA4MXzvPG6yf58UMP4jgOfX19LC4uMjw2Tk9fP8n6JnIFl9bW\nNh5/4ieIaBwrkqKnu48vffH3Ua7gL/7yb5DRBP/nb/8n/uZvv0GqIcXA+Ys4Mk5LcyfX33CAL33p\nS5y98Dq5Qp5cySVV38xzL7zM3Xe/vYKOrlm7gab2brKeJj2XYX4+TWtTHempCWLJBJs2b+HYiRNs\n3ryZ3t5eurs7qUslKBRKbN68mZGxURayi7z8yivs2LGDyclJPKU5e/Ys8/PzZDIZCoUCTizK5Mw0\nEoPwHD16gs1bdv2DnpeV6OfCA/dK2fuTlqIhZhETHuvWtJJMOMxOjZLPLVJfFyfqSCxA+R7adw20\njofER2qNJTxsobGlwrEUtvSxpcaWAiuA0s0msAJFLqUGqQIPG6MkBQh849lKjbQCBS904O3KykOv\ntSYSiRCJ2JTLRkECS5SbpYVpNoTQVQ3UK2o9VmNMmH0CXVEaGhVCizX2VsV70KGXZByYUHkbFKDq\nUdi2jWVJCoUCWqsKfF3tq4YaKH+58q1clxCqFFcJu+q5S4Vt2J+y8nC1j6t8yr6Hq1187eNpH6Ut\nfG2Utesryp7C8zWer3E9D89T+KqWFxqBClAT0zPjQQdwqVYorYK5YZSyLcFCYQuBIwW2AMeCiCVw\nJNXNkjjCwrIkVmhzoM13NEo4GKTEAmGhsQEbLa0VYeblYZirqRo2qCWx4t7lpJGhAg34AiAtCyEJ\nvGqDEEghsGRg1EQkEctA7FaIWAThB4L5IKVBnXQAuwtRnduVuYNYYkia05f2ujLflynGJfPMaOGK\nB72cZ0JWjaDa5k2bNe1oAoTGIDWhUWsF/ZWhMR5A4JZlUS67SMvcV6lUwrIs8vk8lrQq92pZFrZt\n47ouSoKwQvjdwOyBmRMgKQrLEli2ZGZmlsaGBmKOQ6lQxC2ViDY0sGbdOiamppmYnkQrzb3vuJcT\nJ49y/LVXyWczdHR1IuwYO3bs5uFHHqM+mUTj8sAD36WxsY75+UtMTQ4zOTHMrp1bOfTi0+QLRe66\n41527TxINJLiytQAJTfK66fPU59q4sD+G4nZcR556BHqYkl279uD75X45Mc/zCM/+gH7du+kv7+P\nb37jr3nve99De+c6XCmpa2rm0tgY0rIoLixSZ0Vws9M89eiDdLU3Mjc/S8kts2PHduKxKJlsmbY1\nPWTmF9h//S6I2Hz+c7/C3n17OfXKYfo3beQ///Zv49g24+MTfPaXf5mOjjYOvfwyjm2TjER49MEf\ncfjFF9m6eROJpjpEWx3pfA5XCfr6d3D3PfeRmS9y9KWj3LLvIN/9zndJj1/h0sXTRESZ9MwEI+MT\ntPdu4G233UCyvpnuvk1kXMXOfTdT39zFwOVxOhsawbKxS1mefvanbOjv5+a9Bzn09HMcee0og+ff\nwNKCXXsOMDo+ztjoGJnMLNn0PCdfO8HoyDhNqSYi0iaZSNHZ3oGvNd3d3XjKI56sw3YcFnNZ6uuS\nbF7Xzi/+y89y/I2TPH/0KPVx+x/lgf98KHDh3x+LRdGeIha1KZUL+J5HQ30jjm2Rnp3BloJEIo5W\nPrZjBUo0aKASzyTwVBUWoZAHpRVVEC3wgIUwXpMQgdANlWPgoa/gNYVerm1baG0sb6UUvu8RjUYB\n8H2/Epe1pWXg2BBS1tVLBDIm6FdVsClAq5oDhUIrHaCLV4tzg3TKEA82rWlp7ieA8rXWCCw83yMW\ni1MqlZbC4SGcGBoC0hgXCgNlhz3UhglBz66OyVfj5FcrLxO/VvjK2AlKG4879JQ0VuU+ldL4voHL\nDZmbU0IYfgqBVaNIll+nyhsdhAWM10mA1FbDIzrorFEeWvmgNZaQYWDDNCRCw0AHcwWQCik1EoXA\nRwsf8LEIYHVdhemN0QhCCaSWSC2qcC4q8LSXKn0rmDU/yxaSCO65Mt8wRorpg4F9LSFwLDM3qSAM\nVSOSAFI2IRbDuypPlz4XxoBcGcWpjMEKXvBK46W0yQmpnWuBag5NEgP1V9qpMVyFHxgp5nihzfxE\nqyC8Yp5xKY3iFtKMruf7hI+V5xvju1Qu47oelpTksjkikQi2bZPL5Zifn6euro5cNkssEjWoRWAk\n20JWDGDbthDCwvcVnucxcPYsHe0tLCzMoW0bJxrBy+ZpSKUYvjTEYj5LemaWeMLhjddPAB69a9aR\nSNWzZm0/585f4KePP8mBG3aTXZilvaWViakrdHd1MTc3S2Y+h9KC9Rs2ceilF0kkk0zOzDCXnceW\ncXp7eslkFtiyaSv1DY1s2LSFqdk5rFgcDRw7cpj84gKnThxn53XbGBocIBmP0tmzxhgz2SxR22bw\n4iDK94jZDgrF0OAgm7dsZN8NB1nI5bg0fInhoUGaGhtpaW/FQjE3M4sdcZgen+L5Z1+kVCiyY/8N\nvPv9v8DA8CUeefQx5udnufXmm5ibnuSWGw/Q0NjIjh3bGRkZ5ccP/4hPferTHDt+hL6+NbS0tbNt\n23bSs3Okkik++KEP8id/+if85df+iKHhYcYnxjlz5iQXz5/Bsixy2QJz2TK//hu/xeDQIEdfO86/\n/MV/ysiVCbQl0W6e+tZmrGyG4QtnKJVdYvE6tm7bwXe//XXW93ZSl0jSt2EL03MZdu/ai+f7uOUi\nuXyeRDyBQFAslZG2Q2NLE17ZJRaPgRQUXZeZdBoLge8WSY9f5Au/9Zv861/7dW65+27qHPnWV+BF\n5d2vlQYh0cpHofCVwC27JFIJ4vE483Np8oUsdakUvq9MbFn7gWCVlQfVkrV+qhFE5mE2gtfSMhBv\nyni5IhRKBIK1SstjkrUwuhDg+yoQDLJizVcSYwKPwrEstFJIS4KuxsC1MEIrFE8hKVjiVSN0JVGn\nNqZXub/wdxCzXCI/tUAKC+WbuKGUklKpTCKRpFgqLLk/E3cODB6uFsqVLbymqvajNkZpzlmqwEPy\nfQ1aGoNDiwBREAglDFBtTjReuw6hW2OAqACtML5q2Laq/h94+UtMHBEq7EBRh0ZcZUyN8loS+gjR\nFh0cE4ZZAkTGEhosZXIrpEZKhRA+4KGFh6XtwEgUlbizJSSWlOBXlbI01lBgEGhjHgS8CpMohV5Z\nYS9R3sJwpGIcisCTDsbLFgIbK+gH2CgsKbCgBuUxvPSVNrkGCKQMnp0lIRMq413D4iW0Uthlpbmw\nnJSxqkEIlBToakJGaJlUFHiIGIXxfPMcU4lvh4amrkERapGD0HjTUlSUuOXYFEslYok4V0ZHiUUi\nRCNRRkdHSaVSlXBZU1MTM9MzpJLJijFbLBRwLNs850Lgep4xzXwfWwpyuQUuXx7ELebwpGRNdw/l\nzCIDZ0+zbkM/4xNjlL0ibjFHLObguWW6u9fQ3NpJPJ6kd80aDj3zY2LRMnXJCJs3bqa7dz1dHevZ\ns+cmZmcX2LxpG0eOHmZ0bAjbgbHxaW66/W6uv/UOUo3NbL5uB3lPUVSSnftvJNncTjaXobm5mfX9\naxm+OMB8eprzZ96gqbGeoYsXqG9uw7YEquQyl55j/Yb1zEzNkkokKHmS6ZlZbrntVqZmM8zOLtDS\n2Ey5WCZVF2V4ZBgvl2dhbh6NYGZimvXr1hONxSlqwZ33vJMd23fyoQ98gF/7N/+anz71E0aGB7nx\nxoPkCkUGh4d557vfzfvf+36effppWpJ1xONxEvUJ0vNzjI+N09PTg3IEn/qXn+S+e+/lffd9kA9+\n5GM89NDD7Ny6kTMnX8MSio/+yhdIJZIMnH0Dy/JJT08xenkY13dJ1adINtbR6Ps8+fjDnHzjNP/k\no5/k7OAwDVG485YbeOzRJ9i6Yy/dfespe9CzppeN69aybt162rs6OXnqddav30BzezujExO0t7aQ\nnp+jqbWNkdFxPM+js70dx9J856//kldeOcIXv/RlisKhqzHxj1LgPxcxcO0H0K/2cJWPUgRxTCgX\n8kQsSUd7O0JLpqdnjcDWHp5Wxlu0NEoqwoSu5SSUj9RGMGp8FD6+VghhIbVEKAF+NQa2JJa2wm8w\nwsiyahWqwlU+wrawIg5KQNlz0dpH2gLluwgLXO3h4RmFVQMvm3ZEhQ86gPGXx7mN2RFmsftL4Hzf\n968SliEaIIJkOMdx8DyPWCyG1ppisVjNIlYCxVKFGFKYVa+1X+3jMpg8vK7hsa548OEnwkKJqpEh\nVOCZS3PvICsx8HBqVjLXlUYojRV4/r5SKDSe7+MrVeOxVeOlKK8CaWtRjZVW54hcMqbSMhCxVgIt\nFBoPqRUWGltIbCGDvAaTTGkFisGSDraMEiWKIyFiWTi2hSMlUVuScDSJiCIWhWhUYDuArbAtE+aR\niOAageddkw8hWQpPXzW3ARHE5MM8CR+NEgaxUGEWfph9HqArHlTCNUqb1DwsiZBmLod8kjIwgGr6\nEY53xWhaAQlZHk8Oc0euFUsPjTQ/9LelrBjEtrRwLGkMmtC4CbxqyxKV48Jzws2xbGxsE8YKzvUU\nJltBUFmVUSwWWVzMEo8nKJddent7mZydJRqP0dLSwqVLl9Ba09zaQqlUwnVdXNc1c8VXaF+Z/Z6Z\n91KYmLgVZPmvW7eOulQ9s/MZpmbmUJ7PzEKagu+ymJlj9/bryM5nSM9O09HUwomXD/PkU08xPHaZ\nl199hZaGBj7/r36VRx56lG3X7WHr7gO8fuYC7b3dnL88Ck6c9p42du3explTp3nH2+5B6wK+r5ka\nvUJDXYp8vojGYu+efUxOTNHX10ckluLyyDh2JMUv/tK/4p5730tdQyOLiznmMjlaGpOMXr7EsSOv\ncP7MCfK5eXbt3cV8vkAsYnICRsbGyS/maW1oZmRkhEjM4dChQxx/+VUKpSJ1dXVIX3P9/v2kM/O8\nceEcff0bKJd8pmfztLT2cfbsWfr617Awv8hv/rt/w2/+2q8yMniR5lSMK8PnePKxZzn8yiu8+spL\nHDr0Ao8/+jCXBi8yMzHJA9/4W774O7/H2dfP8d+//EecOn6MT37iU8yk53nPe97Ntm07OXXqOIde\nfJpt2zawuJBleHg4kN8u/f39DJ0d4OSZCyxkS7S1tbFmfR/f/s53iEbjZOYXmZ64RCE7S1dXB61t\n9eSLBS4MDVNQHlcmJ3nXB+4j3tqIh8DCYmo+zfT0LAPnLhJPRNi4eQuJujrKKseRV46wfdsuZmfn\nOXz48Js+2z8L/Vx44LlS6f6VIFCoendCCBobG9Fak06naWhoqEDYEMTmCGHcpV5VCLktTzKrxH65\nWqAsh9Brvc3lZPpnBLvnuiitiTkRLMuiVCwghcQOFKe0jXApu15woWobWiv0CtcMEF50TRyxGvur\n8mi58hbL26n5VMonkUjg+z65XI5IxKmgC5YtK6jC8vhm6JWZH0v7Gh6rauDnJYaQFpX7C73lMLiB\nFiuO/1IeV+6IMN65lKpL27Q2Ctl0qRqvrVUoV0GxIaIuTFsGIl7KQwARzLWKNx3CtAG4IEMFb5uY\nurRMglhFGcogXKGMiy2DLPSlo2Ygdn2Vj7uMxMr8CskCs6RMYnI+oLraIIhfa00F4dCCSq7Fm40H\nBM/Isv4tfz6Wx77Ddq86VgokYknintDB0rgAqq8eapgVxssFBOGXcDzDMQ14KExjGhPGMYawCiIG\nZm54nkcmkyEajRKJRJifnye7uEgqmcJxHIrFIrZlUSgUmJmZIZlMVleaSJNb4rousVgUX/mAoFgq\n4rplisUC2ewCuWwO24nS1tTI8NCQSX71FONXRohFIixm5rGEprG+jgM33sT05BS2ZSEtSVNDM2fP\nvs7adWsQjsMrrx5j754DPPTIk2zfsYdCIcuxVw9TLLmUyx7RaIKNW3bS3tlGqVjixImTXHfdVnLZ\nHK5yicXjzGQyZHN5zp4/x/OHXmTTtk00NDVz4uTrbLtuOw88/DDves976O3tZXEhSzqdpb9vPbby\n0VLR0trIK4cP09e/gctXRujq7CAadUinp2ltbWX7ddfxxBNPcdsddzB4cRDbdujs6ebi0GU2bd7K\nhfODWMLmtWNHWb9pC6lolJHRK8Rjca5cGeHllw5hW5p/+onP8L3vfZf+/nU0NzbS091DMV/kyLHj\n7D94gMVilq/8P3/Aow8/yiOPP0pbYyO33bif2ekJZtMLvP8Tn+bMG2/wtrvuYnI6Q0NDKwcP3M7h\nIyepTzWybccOrpw/wfCFk8wvpCmUNVfGZrlx/07mZifp7u1hsVikvXcNSvnMz88zl8mQrKsn2dDA\n66dPs/eGA6Ak0rbJLmRYXMwyPjVNS3MTylfMzczQmnT491/4Lf7i63/NwVtuw3IirO1oeutD6Lly\n6X5YWTk6jkOpVArg3xKxWIy6ujqmp6crD5FSCqHCpVvVc2s9rdrfS5Xz1QLqZ82mXS6cwuVlUoiK\ngrCCZWcq8H5L5RI+GtuxgqSsqudqenO1IvO1bzTDsjhprVGy3PhYfmvLlbi0RMVjj8fjFQ9eSF1J\nfKs1nqqevqIKkV997aADVykB45nLJUZIKGY1esl63r9PaWhdvbnqmF6dHRxCruFxYnl/KjwxvQk/\nRZC8VIHRqc4ZIQz8LLTC0kECmTZxb60M7mBSEhRCKCwJQvho7SGkjw69WW0yrwUyWPZmlLgUIliu\ntpRqld6S+XkNBV5JNBOGD5ZlvGkJ4Vo6VIBkLLHH9NXjVuX71XNMcK3n6up5sRIvl8PxWutq6CD0\nuJcZg5XvBu83qIUOjNnA7CH8lAZ1C+etr02iHAIsaVW8cMdxzMoNz0NKSTweZ3Z6Bs91iUdjaCCf\nzxONRikWixU0KxKJUC6XKRaLAFy+fIlYLEYkEkFKiet6jIyOkp6eY3xyAq9YRPkeMzOzbNi4mZ7u\nXi4ODGBZklQqST6bxfNK2FozOz1FXX0ds3OzKFVmeGiY8clZOnv7OHrkdSanp+no6mBtXz/Z3Cw/\neOBbrO/rZX5uhg9+6IO4WpJOz9Pa2srw8BB1dXV0dXUwMztLZiFLfbyBhro6Rq4MUy4WGblyiVMn\nTpCIJ2ioq2d6LoMlJa0tjbiuoqm9h5bWNizH48ixVxm/PIwlHdas62ddfz+xiEMmPcvsbJoNGzaR\nW8zT17eOxcUs8wuLdHR109nRQa5QYGp6hq1br6MuVc9rJ07yjne9m/aWRu5+29uZnZlF+5odO7Zx\n6IUXiMfi3HTnbYyOXGHo4gWU64G22LJ5C9lsDuV5TE1Nc8cdd/LqkVe49eCN3LD3Oh74zrcZuDhM\n27qtxByLjtZmxibGGRi8wMc+/mGidUlGR0coa82ezZs4/PzTeOUSR0+c4s577iXuSF5+8UVGRq+Q\nd13qW5uYmJhkcSHP/htvJJFKMZueJ190Wdu3npLrIW2bqYkJtl23g6Lr0hCLsJDNUSossn9zP9/+\n3g/5L78IAhC4AAAgAElEQVT7fzG3sICFoKOl7q2vwAuue/+1PNuwYIqBPExRhTDePD09jWVZxONx\nhJRBIYiVBNrV3nfNVa7av/zz76OVPIpQ8dm2BUGsreSWcSIRAFzPo+pt1RYvWVlYVbLUll13pWS7\nirDV176HMDs3PD+TyeA4TpC5XL1u6KGExknV+1625M3sRAhp4pYrxuvlEoShosBVeH/V/i+/n9rv\nYc5C7e/QqKjtc+2yLpOTcG1lU+v5+soP8gauVvZCCCyhgpCMCnShuRMdJIVJESTE4YHQCOWb3I4A\nHdImrmDCArLmXpDVBKwl91pVnrLGQjX3yopUNeK0KWgUrF00HmngtSJRynj5mioPw7aXz+sVw1OV\n61nUohnh8bXIybV5b06rxR6kEBXvO/Rywz6FT4IAk8wYKvxgp6ygGaE8UBAUKdIIc2DQVa11xYNO\nJBIsLi5y6dIlmpub8T2PYqFIMpEgkUwyMzODV3Zpa29nbm6O5ubmilORzWapr69nZmaaeDxOKpkM\nlnIq4tEETU0tPPLjR2htSFEo5EjUpejpW0fZM3H19o4Ortu6i2R9PVpDenyCo0eO4fmK9p5umhqS\njFwa4/kXXuLmW+9gemKapqYm7nrb7ZRKLi8f+in4BWanJ9m7ayeRqE2iroH6hhZisRgDAwNs2bKF\n+bk5orEodfUN9HT1sLa3i5b6JHffehPjly7z5OOPs//6/aTn57hu63Yunj+HJTy2bN3B+PQCFwcH\naWqO89STT7Jp/Xqu27EXO5akUCozMzNNW0MzxVKR1tY2pqZnaG5qRinF3uv3s5jNceH8BeYWMuzZ\nuwfbdnBdl5a2NhazCwycO8/b73knPV1rSCaS/OjBh7h+334mJsb43o9+QCGXZX5mmh3bd7Jjxy7a\ne3rpX7+B3rVruTQ2RckvozX89InH2L6pn/PnzhBL1PGpX/lVRi4Nc+HCWXrWruHpZ59mw8atLJYK\n3LBvHy8fPc7bb7uFJx78Po7QXH/gRj76mX/Gxr517N25i9OnT9O7ro9UUzO7d95ALJpidGycQrGE\nbUfILGRJJBPYkRjSspBA0XXxhaS8mAEpWL9+LemBCxStKL3rN3D+wkWaU010tP8voMBDD7yWagVW\nKARqK53FYjESiQRzc3MUCgWTBS4FylNYlqnSVH3Ml9LPqsCvPhaqWbtVDzQkS8hK5nQodJQyUT0Z\nVEArBQVVTJZqGJ+uJjAtz+4WQhh8U4hAAC+N29by6qrfK3jgVY9dLQlBhJ6FlBaWXY0/1wrgaruh\nErnG+mZlMuA1S5WfL5YaIYIqDIqoGgRvJuhrkZOlBlPtPQZLnqxqHFUEMHdtomHYiyXsq/FAl19X\nWsK0qU1Wty1NcpoZ6yDxCx0sO/MrBWWM4tABX6zA6zZeY8inyk28CXS+kkL/+xS4MmYTCLPGW2sf\n7WuToSAslFZXebihF1w7xa/lWVdGI8zq5+rjV+pX7fWWjDdB4R1ZjWvbUhoDfdk1lxdLqmpxc5BZ\nWRJCO+Y/HYRGwjYikQilUskUaNGaZDJJKpUik8mY4iuZBVpbW3EiDolEgrNnziCkIJFI0NDQgO/7\nOBEbz/eQlqSzs5OBgQHaW9sQQlAolBHCxpYW+/ft58XnnqKnt4tkYwNNbR1MpedYyGcZm5jAtjTp\n+VmSdUneOHmMD33oPo6/fpRsYYH52Syd7e3s2rGDucw0p147QX1dPR/9yMd54rHHKecWaGuqY2F2\njp07dnLp8mU6OtaCtMksZLBtm127dlFfX0c0EjHPuiMYHx3itSMv09PRygvPPkNfXx95v8Rrr5/i\nPe9+Fx0dbfzVn/8ZGzZsYV3fZjy3zJmTr1L2POrrmkimmlEIEql6tO/x5E+eIF/K07euH8e2icZi\nWLbN7OwsM+k54vE4Fy6ew7EtSuUiU9NTbNq8nhdfep7Gpk6y2RLSjtDe1s6+G/aTyWRp62jjlz/z\nz7hu4ya62zr4gz/4Mjfefhv1Lc3Mlwsslors3LWf3rVruOXmgzz9xBMUs/Ok6uL84MEf87b3vo9U\nvIHRkTFuvvUuHDvO/FyBzq41pFJNNLW2Mz99hUJ6ghef+Sk79h3gpjveyfPPPsv77n0fP3nscQ69\nepibbn07jlVHMtnMwsIsExMTtLW2s7a3F7fkVpIno7EYI6PjNDQ1MXzmNGv61rChby1/97Wvcuu7\n7yMST5JK1DEydImtW/v+UQr85yKJTQWJNLWbRla+u54RQwgL11MoLcgsZPF8TUdnNxrJxPgUSiki\n8RiFcglYGY69lqe//HMl7+vq85YW79CiVnGrAKIWNYpaIKVNLlfA8zzj8QaK3FwnrAAlTDlSLatl\nSQM48c3g5ZX7uDL0WvXQZMWDTSaTlMtlSkUX3zNLz7QSuGUftFyy7GsJfF5TKGQ5/yr7hNlvMu+v\nPsYkWRl+Gp7WZGgv+Y/Kp9a168z96nlowiVS4X4ZeGCVREVNsOkKlKy0xtfe0izvCsN0pW/hmAsh\nliAKEhEkolUr8RneCgQ2UkQQIlDgYYxdVMMoSxTZmxQWWjGGfA2SVBMPfa1QCvPpgzYZgyvO98o1\nKrbFzz7vlverFhWpNQZr25Q15y6H18Owy3Kem/MVlmObzarhmzZhjlqeSoTJ8FfaVAxCUy6XiEYj\npmZCuYxQimQsRkdHBz1d3SilGB4eNsvGAiNiZmYGKSULixlTGClACnO5HKVimcLCAqdOHKWcy5HP\nLjI8OIRSisx8mr27drKwmEZamsnxUcbHx6mrbySaSDCXW2R8dpbZbA4iDucHB7j9tlso5rI8+uPv\nc/OBvbz9rtsZOHuOt991M011Nk899hCZmTF6OpsYHrzAO+65G9s2qOTY+AiWgM72Djo7u1lYWGBq\naorxkSskow5zU+McefkQtx28Hr+Ypbu9jVQixa//21/nM5/5LCePHKM52cBHP/wxvvrVP0ZJl5Kb\nI1XXwLq1/axds476xkbK5TLJaITerm7aOtrZtHEL/f39FMsuhUKBgYEBnGiE5uZGmluaWJjPsHXr\nZqanJnj6qScpFrLs2rmV1o5ORiamGboyxhsXBmhq7eSXfuV/49VjR/k/fu3fom3J3gMHeOe77uWL\nv/vfeOKRh8hMjdHb0YL2PaYnxzl37hzvfe/7+f73v082m6Wzp5vmxiTd3d0oIRGW5LrtW4Aia3qa\nWFyYoZhdZHRshlRLG2NTM7z44os89dMnGJ/JMD23iMamo6OL3q71OHaCpqYmuju7GL8yQnZ+Dq9Q\noj4RZ+DMGSZHR5FSkEjESCUS7Nu3h5b6FLpU4qfPPcudd+wHz6VcyHLy1LGf+Zm6Fv1ceODZUnlJ\nJ4xg1hXPKFQYtYpDCGOVe66HZdnUNzQghFnakM/liCcSgUA262zDdcMmlUnU+Ao1ZU9roLrwulfH\nd32qkVsVaFXTTlhkZDn8rZRR5J5nYOhIxAjyYrFUWZImhBUcu9QjNMK9Ni4ertcOyoiaIF8lmSr8\nHsYTYanAr8afJYKwKI3E801deccx617z+YLxLhyH0EtVKizIgVH8YTFSHcQflYHDK+u3QxtBKDzt\no7UMHKEKfmnQicCLkssEd3gfJuNbVorRCHNTECwjq46NKc5j28YLl1KbJCABytd4ysNXBgXx3DCW\nD7Weo7RE7c/KOnKtfESwHtxSVLK5lVjqRUohTUKVAoFtDFEsNJbJbA+MBq1MvQAfASKs5FWFz0M8\npuLZhhZciP5Ufr852aJaUjZsWYpg7JS/ZLy06ZxBRmqSFy3bXoJkmMqBQaa4lNiOrJQrtmwrSNeo\nPiNm/TVIWa1YFs7HipKu6XP4/9IVGktXWaigwr3SmpJXDvJEQsi9moluB5slLWzLxrIcLCmxTFYf\njrQqyXJSSiYnJir35fserlumuaWZ02dOE3EcNmxYj/Y1c+k07e1tFAtFwlS+02+8QWtzK7OTV1iY\nm+LkieMkEglm07OgfEYuXSRiWQycP8nu7dsp58uook/cirChey1WMkUy0Ughr7n1tjt47LGfcPyV\no2zv30R3bycvHXqKBx98gO6uHlJJzbe++XWu33cAVSxy+vXXaG5qpL6+lYuXRtm0bTtl38Hzykyn\nZ0nW1aO0ZmZqmqiUjAwNUMznOH36JNryWSgVae7sZe2GbRw5cpKN/Vu44ebb2dC/mVOnznLm/Hm+\n9vWvsnHTeq7ftY9kvIE3zp0l2dyIVy6yMD/D6PgVSqqM9jXnzp5n954dZDKzZDJzFAt5tPKZSafJ\nZRe4PDRExIrygQ98hMmJCUYuDXPDgYP096/DiVn0ru3G9VwuDFxkz+7NvOt9H+HIa6/zw4cf5zvf\n/jaf+fBHuXP/Hn78wDcZOnucX//VX+XFp58iPTNDYzzO+971Dl449ALZsqKnu4XHHn+ZX/wX/4ps\nPs/gwBnOnzxOU32E18++QW9XH5NTE/T3dzE2Msz5gSHWbNjMB3/pczS3tXDoledp72oh5jRRX5ei\n6GXIzKV52913UcxlSSaiFHKLPP/C06xb20NmYQ7fLaPyBTJz43Q1NvCl/3I/x88c4Z9+6rN895t/\nxR9+6b9x6tRhPve5z7/1IfTFYun+a1nmsNRzWgk6DuF13/eJx+PYlskqjUajVaETnGbZFr7ysaSD\n0j6msppfWYKyZDmUXuoFhd6U8YqDQp6m9oeBwaUwSukqb8UoOWMcVGONlnQol108v1wRbmEJZxVm\n1epq/fCV6WoofyW6Vpy8qiwlFbWhNbFYrPIShzDBp5bvIlBsYfY4hJnMBMVrQoWkDXR5VdgiTDYy\nNx3yZLl3GRoY4TiEhXL8IHtaElRMk7LShsDUyZYyUlGmlexjZV6IYtUkvYV14c1ckQgrLLRiUQmZ\nCtChskYhZfAik2BcQ35W7kFplFYVT7/6n4/GNf3CRmlT5x1h4wtJiDMIIYJlfVRq9L8ZhagGFXjY\n8NE29QuR2sSOLWQQirFQwmRjazAhDCHMPMaiUuRIWoYnQeUhKYI12iIwCqRJlBOBLRsaV6pmHCtz\nLFxTX1OaNVzHrmv4GM6x2nm63FsPzXAZDM7S2RWsjRcCLU1IDcxKgLLrYTkmeQ1b4vl+xVD0PY/m\n5mbm5+fJ5XIk4wmSsQTTk1PE4gnGxsaJ2g7FQpaZ6RmcIIHNdV3i8ThTUxNcujTEtk39jI2M0NXd\nTVt7DzPpNLatQZV4/uknyGTLdHT3sm3HDiwLpmammZ2bY+D8AJn5OZyIRb5cpLGxiZdffJ4b9+9j\nZHqUDZu3sjAxRUPMZiKdpr19LTfd9XbOXBxkbHQcr1jm+psOEm1swtMO8YY6du/bx8TUFG1dPVh2\nFDeA/K9cvkhmfowdO7eTrG9naHSGe97/T+hc00+xrEA6yESSubyHk6jjvl/4AJeGhnjlxRcZGrrA\n7bfdRl0qyejYFdau6cYt5rHRbOlfx+OP/pjbbr2RiO1wceAc27ZuoSFVTyKa4PixI9h+GXdxnrVr\n13Dm/EU279xDMWKRm8szMzeP0Cbc1dXWwdTkOMWSIFpXx959t/Cxj3+UPXsP8s1v/5A/+6uvMzk9\nwpaNW/j0Jz5MZ2szh48c5dkXn+OlQy+wbk0v02OjdHavxxMWb3vH25kcH6culuCP/vAP+fhHP0lz\nUyeLrsXpw48xfnEQt1jg1Lk3WLN1D2u37qYxEuXws48zNTnMwYPvI+ok6e1ppaGhkWy+iHAcnGiC\nhsZG9u7djZQQi0SZz8yTWZwnm07TlnT42lf+gP17djKXnuOLX/x92tva+Z3/+AU2bbvurQ+hhw/o\n8nXR4X8rrcsO94Xrk8MHXSlFJBIhl8uRTqeXHCeEoFwuA1Aul7FtGwOvGk/Udd2r1lLXrnk1bRnl\nHb65ClhR6NT2H2rXfPuoAHZDKJyIqdpUKBQq9xG+JEUEMdvw/JCWeyb/EB7Xbr7vVwyfcAv/C5MH\nwwSfkBfL72ulMfrZ+vPm65tr2wr75nneVXPB9cuUXTdICqRiJIEM5kaVd6Eysbh6fGr7vfz45f9L\nYV81HssNv9rlUJV5pIMStIEBqIO68Gb+rYT2BAlxfw9fw/i+DBSZuUeJhURJo6CV0PhS4QkfBXj4\n+FrgByVs/cAwDV8UI2QEhENYYMbXqrKJYDOhCDMmphq8DtagrwzvXyskUMujFb3zZYadwmSTh9e7\nql1dU8vAg1LRJL5qJSqZ5o4dwXe9itHgui4R2ywXa29vx3IkYxOjSEdQ31QHwmcxnyHVkCSWTJEt\n5Ik4URqbmpmbzwQllWNks3kjWxxJMpnk9BunWN+31qwVLxZZv2ENmUyGY0de49BzLzE/v0BbazOl\n4iI3HdxPPpuhVMjT2NDEDTccpKt7LT965DGam5uJx+O8774P0NbWwXx6jq1bNjGfnkJJeNs77kYL\nE7abmZlhcmqcGw4cYGxklMvDl2ioS5GIR5EoBi+cp7ujlXjU4e4772J4eJjbbr+T8wODnB8cpLWz\nk66+Ps6du0DfhjXUtzXiSsnv/O7v0dHRxpnTr3Hy+MvkFtP09PSQyxbpXdtPLl/i5Ik32LBhE5FI\njFOnTpGMJ8w6+9wCM+lplC4zMTHGpi0bcaIOu3fvZDGzCK4mmYxTLuTR+MymZxgdvcLQ8DBtbW30\nrd3A4OAgFwYus//Gm/nWd/+Of/FLv0xzcw8PPfwEzS2N7N6zg7/4y7/i8cee4jd+6zd58KEfMZNe\n5OSRl3nfu+5hYmKMo8ePUFaK933wwzz6k2col12S8SjDg+MsLuTJLyyQiji887Zb6G5pIrcwB8pj\n27YtNDSncOKCHz78Qy5cHGBg8CKTE9MMDAwyOjbF2OQMMhJjfHwCz/PIL8xz4/59DJ4/y+zMBPfe\ney/f+Ntv8cnPfIov//FXGJ+euuYz/bPSz4UHvlAo3l+r6GppuaJYSQDIGnjVHKdIJpN4nsfi4iKR\nSIRELF55JaAQAidi4/tuRXmHHkDttZYLzRAqrv4nlm4r9L3W86p4nroGGsXUKY9EIhQLZVzlE41G\naxT30tdlQlW4Vfr397z1YiXhL7ReIvStEGY1GDeu61Zg01Cx27ZdMYSAYH81MzosARvGuc2FjBdu\nliiJyv0v7VdN7HdZnH55OGMlw6G2FgCICs90BSIPPLaKh1eNcIdw/tK4a1CONKiIF4YuLEtiWxbC\nN2GTkHeVDOoAHl/K6LCgr1lGF8A1hi/aDjLzg9fIEuQrvuloLmte6auGvzZJC4JiNlQuW10zLazA\nc6+GlcKIkBZWkP5WrXam0QhRU7c9fAlLEIYwx5nF8IKllduqc5Zl87WKIC2Pf9c+j+FvKaUJX0B1\nYcYylmsVGlVGFpj5IQMDRJMvFLBs2+SsBOe6rovSCsdxmJqaIpFI4ns+xUIRx4ng+j51dfUUC0V8\npSkUi9iOTXt7O/l8nvTsLLZtk0wmWZidwHfLTE9Pk83lKJddXLfE4MUL3HTTPtrb11Jf30JDYyOl\nQoGzZ15nanKCvrU9KG1KM3d299Dd2cXs7BQPPPAAN99yA4vZPBE7QsR2eOHQs+D6FEtFEvE6xgcH\nsbVicXERYTtoBBu2bOTcGyfxfY/2thYcSzIzPsqu7ZuZGr/Erp27+f3f/+/EEg3U1TebTPxYjGxm\njua6FF/4wq/TvaaD4UtD2NJi+MIAcVvjFhZ49pmfsHfvHpxkC93dfVwYGKbsehy44UZypSKbN29l\nZnqak8dfZW4uzbatWxgbH+PSpWHW9a1FWDY9fetZzJdJJWLkcvP4nsfCQoYnnnic/v51dLa3E405\nlFyP5rYeSl6ZgufjC8HU7BQ7d+7kvvs+QLns8uxPHyZXctl43T4WC0XaWutYt7aLZ558jgN7d7Ju\ny1Y6e7oZm5xkXX8fba3tPPPMM9x+251YcYfvf+d7HNi3h7NvHCMVjzKbybBj9z4uvHaEsaGzzM/P\n0NK+ESEt9h+8HoRFW2sHsWSKSDRKJBZFSBsrEiG3MI/2fZpSMdrr43z9q19h29bNdPb08NSLr/Jv\nf+Pfs5DLs2nTZjo7O/7X8cBXVDRYBspkZaseqFjVWuvK0hPfM+/ubWlpYW5ujrHJMRzHvGwCVOX1\nmrXQ3XLjYXn/wFRy8hSVhK6lHqGoeHy1m6mEFcDvuva7Od/3NKWiSyRYYpbPFyre5oqJZ/8AXq6k\nAI1HFb44xKfsebi+X/XEdLU8LFTfuhbeq+d55p3JwbiEXvzyMQxLsi7fVupX0PsKXF0r/EMKhe0S\nPljGk/WpRUt0sFV/h9cxCWJVhVD78pHaflVeSxl64zVJZQpRedtr+FY1T/nmPdErGBkmCi4M9C6C\n4iRhFXUh8E3aG0oEYRkhl+uka5KqdTyDTdV4p1KD0DIo1CaCE2Rl/oUec5jMF7ZXGTv8JWOnfFBe\nsCROS+PtCoJEs4B/OngZkBBLKtitRLXKevkxtQarVTsPggyO2gS75chMFWXSCGEgc9c1eR7FYpH5\n+Tny+Txl38xlK3xRSYDEjY6OIZBkF3MkonFiToz8Yp7RyyPs2rmDufQs58+dJRaNEI9F6etbg1A+\niWgEITXf+953QXl8+EMfZOD8GSbHR7BtSaFgDONYPMLGDX0sZNIUC4vEYzZDQ4Ns2LiOZCrO//jT\nr3Lq5GvccdvtdPd2MXBhEMeJorRgZm6ed77jHubT01y6cJYmRzJ2/ixdDfVMXhkBr0Q8avPqkUN0\nttQRt12GL5zi+OHnwM8zOX6J+roEr586T3axxAfv+xBR6UC5TEL4ZEaGefTvvsF73nEbr738POva\nW0lIja193EKe//1zn0damu8+8Lds374dTwgaWlp42z3vJF6XQjgRZmbniEQiTE1M0NXWhlsqkltc\noKOtnfUbt+AR5dLlCVpb2nn+uScYOHOCNT29tLe38+lPf7oiY9yyTzKRIlcoEquL09DSgIxFyBQy\nyFgEIgk+9c/+Od/74aPsO3grP3zkYV4/fx4nnmDPrt3csHsbt91yE5//3K/wjW/+FXv2bCMVc+jp\nbGFxdoYLQ+cRssiHPv5pbrjjDqLJBJ5yGRsZ4sSrz7O+t51ExOHwS4fZtmkzh196lXOnh5iezTA1\nm0YGYdfpiUl6u9rIZebp7e0hFY9RXMwwNXqJ82dPkYw7fPnLX+bvvvMD2tq7iSUayWRLP+NTfm36\nufDAM/nCkk4shcPC78u83Zrkodo4mfnXCILwPd0NDQ24bpn03BzJVAohJZawUMq/SnjXQqHLYWED\nGVYjjGYTwcqyqisQrrEGCCNsvqrNsF+6KTTSNt5QJBJBKV2B+GsV6XLPu9r3f4jPFiSeiTA+rc0S\nN8LfQM0Ss9rwhOu6aGXqq4cx4OVGTyV2Hdy3ohoL13plIa61Dl4CYt4cF+RoV+KpmvCNW6LyHubK\nuaLGc6MKJ4cx5LDet67xknXgE1feIV7DW0I+BJ6iSb6S2CE6EaybFksKoeggoaq6JKvCDzDxYilw\nMIVdbClAWnhaorXED9oOjQKzBloSus1LVz4vfw4CngthchDCG9NB3Ddo2JTIxZSUJSgtq7WJ6xPy\npIoVVLPtzbhoZQwBAq/cVKqzAo9bIMIExYDfUgcvdBHGaEHXVOjTS9GPSrx6BWOzoty1QY2CJ84Y\nQwQFXAhzMoJ2w6ViQe5EBSHSGsu2kZZFLpdDEyTiOaaOeblcpq6+nmw2S3ZxgeamJlLxKOPjo1gC\n5tKzJBMxLKEolQpEIzZNjfXMTk1Sl4xRKhXw3RL5XIahwYtkMvPs3LWDnp5uDr/yMq7r4nkWQ0ND\noD0ijmRo6Dxr1vTiumU6OntwfQ8pbXZt38H3v/N3LM7PMDl6Cdcr8+nPfpZy2eWlQy/RkIySiEdx\n4lFiiQSF3AL79u6hpbsdbVl0dHWRWZjh4utv4LklNqzfwIXz5zl3doAN6zcyl55jdGKUnp413HLr\nnUxNT1Mu5ynkMjSkktQlktx177uYnkjz4x/8iFQ8xvTECLv37iY9n6G9o42XXz3KbXe/m9fPXmDf\ngRtYzGaIRiXPPP8CPb3dFHI5vEKWcrlIe2srh55/gR27dzM9mybV2Eh7Rwdj4yMkozFuOnAzI+OT\ntLe1MzszS2dHB8PDl8ksZFnXvwnt2PiqDJZNyS3jqSINDY1cPD+I65fJ5rL89Lnn+fznf5nDLz6L\nI8AvlBi9PMjE9ByxhkYGh4eoTyTYvX0LA6+fYmRogGjc5uZbDnDd9uvJ57I8/diPKOcXWdPXx63v\nvI+IE+NHP3yQvOvR2NZDe0cnIxP/H3PvHSXZVZ19/84NlatzTtOTpydqRqMcBqEsoUTONsbYgI3t\n18bhBWxjY4wxtsBkGzDGNgjJCAESApRHmpFmNJoceqYndM7d1V053HDeP869VdWjkQyLb31LZ61a\n3VVd99atc0+fvfezn/3sCeoalMRuTTxOIZuhoTZKPr1INBhgYSHBmYETUMzyzGM/JRY0SCQS5Eo2\nBWmSTGcJhsOcGTjJJRdf9GtF4K8NA54tfrK8e/n121LwSmnSMhTnR09S84yKUKxaV5HTHMfv5OUS\nDocAWFhYACBgBjx2+HnRkqaV5TfVn5ZumH6jMLVpesIcHhlIUA2z+w9NbX7lnsa87LyaR8ByXRXd\nGoaBYRjk84oJbhhGGSGoTiOUDfl5IiiVSNHfnCsfV3Y8BF5XJpXHVDKgmme8hIpgJQhNx3ZcDMPE\ncSWWbSE0z2B4UZvwKM4+Sq5iTsWodxG40n0ZfH7+/VT7r1ve1IV/Mm/Syq0g/c/ya3+rUgHV51Lz\nVHEolkTy1Z+hPsB7j+cA6Lpn6EX5Nd2fYrfiiChHzfGUzhRkrGlevbjfREPoXnpClZgZ3t8FEsup\n/q4ueF3ztCpDJcvXV512kUuuX3jGu3qoNanuua+L7gjNuzeaZ/78G+B7N+CX4VUjIZq/dr1FJLx6\nfp9wpxB0dV8Uwi3KRrYaOnd8Gd5qkR9RSSuVXyvfv0pkruERGhEgPffQR1K8rnPScwQqDoJSZnRd\nWVp7hGYAACAASURBVNaPcFyHeDxGyS4xn5intbWFgKFj2xbFYoFQOEgiMY90imTTCyRmJ6mrjZFJ\nLxAMaDTUx3ni8cdYubyXpoZ6wsEA6VSSdCrF8WNHWbt6NT988EFuvukGJiYmONXfT2N9AwOnB7jk\n0ksYG5mmpaWB02f6aW6pJxIJEwiYWCWXaLyGYCjExMQEHc0tdLe30lQfYeDUCcLRKLlSiVymgFUs\nYFk5ZqZmmJidoX31cvYd2EcwHGJ8doZwTS0bN26kPh5n8ORpLrvkMizbYW4uydq167l4+6UMDo+y\nclUHnR3djIyOYbkOeTtPa1c76WyBmsYmjGAdq1etJRgM8sD999HQ1sT1N9/MTx9/nLe87R20d/RQ\n39zO5VdeycHDh9CEJJdJEYlFSCYSRINBsqkFWpuaOH1qgIu3bWVkbJxYfQ0tbc1MTY0zNzvF8p4+\njuw/gYXi3diOpL2tDcd2OXdukJa2DgLBACXLQhOq3a9dshDAzPQUXd2dXHnN6/nCP32WufEz/OOn\n/oqdTz/N4NAIAwMD1DU0s2HrdtatW8cn/+oTXLZtCxdt6GNocIDOznb6j/YTr2ti5zM7aYmFWZia\nIF8q0bt1B7XxeoqWzcTMHJdedQUXX34Jesigb+16rFIJDZuQqXN43156OlsZHxni9OkBrEKBt7/p\njdz/3e9glwpksln6Nm4m2lBPQ3MTra1N2MUcGzf8eiS214QBX8y+PAJ/eZR5oSHK+S4pJbpuqDyu\nELi++igSTRfYtoKoazwPO5fJUVtbU2lKICW27aLrxgVh0Ao5yY9XlhLJpJTgVCI+f7jyla//QpCy\nH/lqmkYoFCrXkFe/p5qhrVCHV4hsz/ss9RPwc7E+oc7Ps0tXsY2rz13lLPibqYokbI93oJchdISX\nFkB6RuJ8rsDSa6keejn56gug+MZYInSP6SxUKZImVHRaZosvyV8vNdrqwZLnrwTnlgVfdK8ZrfSR\nD9Vcp6LLrVpxaprq7GUYXqmSri0xOrquew1PvGuo1HKBVA6Shupq5veo1/1SNT8q9wy6inlf/qiC\nFUDKivyo9O6ntnT9yaqFIaTAF1ArIxgITxil8ihD5AJA95wDv3e3KN9e12vfCaKMYvgOqytlBTmp\n1tD3yi7OXxMvv59O5YsJlPOuqf/t8n311lzF+VPz7ji2twYkqXQK0zQUm96xWUwkiEbCZNIpauJx\nTMNg8Nw5WlqaCAYCjI+OEjB1CqUC4xNjbNlyEeFQkJ/97FHm5+doa2tlxYrlTE5OsLCwSKlYQtM1\nVq9ZTTgYIB6LEQ4FOTc07MHCDuPjY0QiIVavVsSsaDRGd/cyzp49S3NTI4nEItKyyKeSFHJpauNR\nHvzRj7j0iivYsGETx48ewdSgoamRYydPcfdb3szQmbMUCkXMcJypmTkOvnSQM8eOIXSN6bkZamtr\nOXT4MLfdehvT09OAZGjkLOvWbSIWq6WxqYlgJIDQBIYZIBaLY7sghEMsGsKyHRqamnhx335+47fe\nz/4XDxOJxvjqV7/Ou3/jNwgGAoyMDGIV8/R2d3Bo/wFOHD1OXTzG5PQEpwdO0tHdiRkMowdDlByN\n3p4VtDa3cuzoERJzs+ghg2XLeglFQswnEhw9epRLLr2UdC5PYnaG2lgt0rIIagbClmjSpVjIEo7F\nGDxzhku2b+GJRx+hlC/Qu2IFmWyamclpDh8+TEt7D1u3bWfzpi186m8/xTXXXoWUcPDwYb7//R/R\n3tvD5PQsxeQixfQC49NTmI3d3HL9DTz84x9zdvAs73nfOzl48BB5y6ImHCeTWURIl/bmBnq7u3ji\n8V9w5MgRamui3HH7rezds4tvfePf2Li+j9//yEdobe9AmAGeeHInRiCAdGy2bdv6axlwcaHN9P/v\ncW5yTp5PIIOKCtuFxvmG3Y+Sqv/xK/Du0jynEIJAIEAysYCuaeUmKZZloXn1o6VSCYS75FpcB6T+\nCtfjyqrz+79rZejS/17nG8UL5V/PH4bQKNoWxWKRaDSC41RgfkMYIBWbXpbztDqOozq0ua4PNbrl\naN5xHNAVYWf03DAH9r/EFZdexrKVK1nMZNF0D27UdSzbLsPSAAK9fJ6SVcC2baKRuGKKW6pZi+1K\nXE29LxAIYNslL1/5cqTAH5pbcaQuZIyXDq0qOF/qALnVx2gK4hfSg3uXnNs//5K76F+cdz5PjhVH\n5bGFMsq4Ek33HYpKBy//2jRZubeOVzboeh2xyqiNBNsqF3GVyVkuWrmxR8lVRs/wIWYXLC+3X4ls\nHXxYW6VnHPx+9mo+qtfl0rWmoSOEQ5mMBuW8suY5Xy6g6xXWvc/y99e4lOr6dFA8AVQ1gFSJde+k\nvtZB5f7r6Etc3WpH9WUIkxBITTUIwfEqCYTE0FWE7YhKGZ9/nOv9FLaDNJTTKaXEkBonTp1k3fo+\nivk8MzMzCCFoaGggmUwhpSSTzrGYnGfdqtXMT83guEU0Q1BfX8/xoycxAwE2btzIAw/8gNWrV3Px\nxVs5fuIoATNEJBJjbnaaJx77BatXrmTjxo3s2bMH23KZmp0hl09x6aWX0t7Rw8CpM7S0tHDq5Ak2\nrlvNwLlhwh4xrnvlcgaOHaMuFuHkqWMIM4QwgwRDIZA2+YJDLplg784n2HDRJqyixR233sVCssBN\nt7yBb37n2+TzCeK1cTQTjp84yYYNmylmcrS0NvOJv/ob7rvvh/SfOkV9XTMH9u8jkZglmZpHD4Zo\nbG6ivbWDjevWklpcYF3fGoQWoCZez7M7n+eLn/8cX/zyV3nhxX38y+c+zfhskhcOHmLfrie54vKr\nKWZneOrZ3SzrXsHo8Cmi8UbyOZtIXR1X7biWWG09UgQZH54gFixysv8gbb0bqG9qpKt7GUeOHCEe\njdHd2UlACzA+qsRwcpk8xWKROg+CP33uNHNzc7S31XLuzDmuuPQqTvYf5bOf/Wse+clDREIxLtu0\niX974CfsO3yMa6+9lpqQyUc+/EHmZiaQ4Qg/e+gJUjJDXU03B3c9xejJ3XzrX/+VD3/yc2xcs47h\n02f5vx//GF/5xhcww/U0NC/DymbJ5mcRrmB2KklTY5yGulqkdFi9ZiV/+id/TG1dnBuv28Hc1CQN\ndbUYgSAi3kZjYxPx2hqy6QzbL9nyahHq/zpeExH4Qib3yZcRoM4rJ6serxyVv/z9S41k5e+O4xKP\nxbEdh/n5BLpuEAgEcRxHyQx6rSV93XUFYTtLemUvuabznpX7VFe99Vdxlqrfa3ntP/3Wh1JK6uvr\nValCKYdmKGENV1q4rq3Y9cKPIJWKmdBAGBqOdHA0SbFYoL2lhb//u0/z93/7N9xww/Vs3LKRRDKN\nKQwM3fT0wNVmqwvFvnYR6LpBqVQkYAYxdJPh4WHq6urKxC8FZaouSpZloXlOzPlO1JLn0l2yCS+d\nzqXQsZ+qR0iv5lx6UaSX/j1P5EQZjkqu9ZXWj/+yFD5qUJFV8WuO/XysrglPRlV6vbZFWUgHXC83\nK7y6fqHO6apzVRMJ8bLGtlRGWAoVRbuuq+RaPRRC96RaDU3D0ASGJlSLTeHXtGt+ZtqDwRV5DAzl\nwKApg+1TwKRWMaxaFWoB+A6BxxRQP0VlLsqGUuUqvFpsBapLP/3lkw7UjVIoivf5SFH+U/XdvhCS\nUnZUhM+cl0rX3HN4hJBKrAa/vE1VewipcKBy2keovuymphEOhRgZHaGtuQVNCE71n6SpoVFpnodC\nChrVJL3LesmmM4TDYebmFgiEQkxPzSKESsXpusptLl/ey9mz5+jq6uLkyVOsWN6LVchz9uxpFhMJ\nXClp62ynWCzhOEW2bNzM/HyChYUkyWQKJBw+dITkYoJcKkk8FiWdyyFLFqMjw9h2CcsB2xF8//vf\nY9WqVaxa3Uc2m0fiENF1NqzfwFwyybotF3Hk5ElW960jn03juBoNTY3U1tazoncld9z2Bnbv3oVE\nZ82mS4nVNtHY1MR1r3sdHW1NrFq1nMsu2c6K5cvRjDBP/uJxXnh+D4Pnhjh95jRdXR1MT0/yO7/7\nW3z0o3/EDx+6n29+4+vsPnCYpu4VBGNRNqxcxre/8WWuuPoafvCDB7ntlhuJ19YxPT3PytUbaGxp\nIhQJk03niYUbiYRDSru9roGamhpKliLwdnR2kEwmSczP4boKGVu7Zo0qudUkqjFsic72ZlrbG2nr\n6mZxMcu2rRdxuv8En/n0p/mbv/ssh/bv583vejfDQ4OETZ09u3fxhltuJJVaoLW5jfa2NiaSi4yO\nzTA2eJonf/4wueQiU8lFNm/YRCwcZfcLO7n40ktYSGZZSKawshmeefoJamK1zM3OE4mG6OtbjxnU\neG7nk4QjIaanp+np6mRxcYFiMc/c3Dz9gyNMzs7w4EMPMTM/x3U7rvm1IvDXBAu9LG/pyY9CBc6s\nrvkuM2FfgXHqH+84Do4tcezKa9XsZMdRr+VLRYLBYJmpvrCwgGEYRCIRpCvKx/n14eeP8z8fn+Xr\niirZ0Ze/75d5VJ9f13VKtoXl2MRq4iwsLPDEE09gWRYtTc0qWiuV0ISJJpVcpAZKKtMR6BiKPexF\ncJqmIXQDgPa2FlpbGpifm8KRXiRoGFhSgmFgmkEcqY4Vulm+L4bH2g0EAoTDYT70oQ+hm4ZiZNs2\nrmUjbBfTqyPWdb0q+/ryx6vNreu6nu6pW45i/UizMvdVxCe38rjQWDrXDkI6ngFwPChWLjFY5XWK\nx2qWbpkAp8yhrGp9WRWNu46H4rgeAYsl38mVAtujY7kSLOl6VQ7qu2qugy5dNGxwbe86bQwcDBw0\n1yIgdAxkRfNNyPJz4eWKFUcAKrTJyrVXzwnSly+WOK6GK71SMimoZpu7fprEVQiCoxJKHtqgeA/e\nBCkjq6sr9gl0QuiqTE1cmAh5wXw4PtEShZB4ML7l5dbVwydPVox/MBgkFAphmiamaaLrguamBsKm\nweC5M/R0d7JxQx/Hjh7GdYogHSYnRrGKBVILCZqamlhIJMlm80xPzKILjXQuTX9/P4ahIaVqL7l6\n9Wp2795dbhwSi0Vob2vh4KH9FIt5uru7KVol+vrWcejQAa68/HIE0N7axp133EVrRycd7c3YVpHa\nmhiZbIp169YBsHHzFoaHRtmxYwc3XH8TTz72uPpu0TB79h1gZnyKtpZ2Lt5+KefGRoi3NHLRZZfi\nolHX2EomXUKTQTpbuhg6O8Lunbt565veSiaTo6+vjzWrVnP61ABjY2MUCxZCCxCK1PDhD/0uH/id\nD/PB3/093v62dxGJRPjSl/6FXbufYnh8lDvuegP3/fe3ufO2W3ji0Z8wPz1BY2MjTz/+KFs3baKh\ntoabb7iR+vp6Tpw4yYoVvUQjcY4cPIR0S0TCJsGAwfDQGIlUls7OznKjGDMYRjeDxGriiIBGMp0g\nnU1x8Nghdu55jpJrIw2N9rZOUqkU584MEwxEmZqbI5nN8X//8hOgubzxjhspuTbTU2OsXdPLwKnj\ntDTGmZ8ZJxYwmDg7wHe//a/EYnWs2dDHW9/5bqKxekBw/NCL9B87Tl9fH81NdQyNTBCvrac+HsLO\npnn7G9+qJHZ1SKaThGpifOFrX+DB++/jU5/8JLt37+bqa3aQzRfI5AocPd7PsQN7MR2Ld7zpzVx2\n8cUX3J9+lfGaMOB+frVatOR8YZELGeuXSS26VcdKb3NxFXzpuGA7FUEKiYZVcsgVSuSLFg1NLViO\nZHR8knQuhxkK4UiBrpkYegDHlmV9cl+jvPrhOkqu03WkL8OtoHP//edtSv7v55+nci7Kz21HlvXI\niwWL5qZWXNfl1Il+Xti1B6ckCehhigUXyzYQBLEtMEQA4eo4jkAIEyENTBFEk4oUV7Id2ttbKRXz\nuI6FdGykdJTIh3ApOiXydgFbOBTsAtlilmw2TaGQU3lwp0SxlKeltYm29hZcaaHrgoChK7PkGUHF\nIK7owVdDpP69vBBkXjbI0p838TJjXT2q9eLL8KsrlWGW3k+3YriV8wDV+usarsqtVsyF4oCrJLZa\ncz5zW7gVQ+b62vfemsV3+JSDIlyPPiY9DoUA1z8eWZZk9de964DjSEq2L7Zj4dglXMfCcS1cxwLp\nILARmouGgy4dBA66cKseJfWgiCFKGMLC8J5rnvtQ/r+iokomhARR6UsghQbSwHU8Jrrrve7F/b7x\nrLhjHqwtdA/OrvQ2cL3vr/5Hl1YVVN/7pf8vmockAOc57CVXo+gISi5YUmBJga3YBeSLhSVrzC6W\nyKbSNNU3sDA7x+n+k3S0tWCXCoyNjJBJLSKkQ0dbG47jkEgkWFxMkstkmZ2aJJdeYEVvFx2dLQhN\nspCY45mnH6e5qY66eIyp8TFKhXyZB/HBD34Q2y4RjgSpq6thaGiYhUSCg/sPUMoXMAMGxVKBFSt6\nyeVyxONxdu3aRV9fH4ePHcUIBGhp66BQdGhpaePWW28ll8kzOTHC63ZcRUtzE/l8npm5WV46eID/\nefBBDMPg1KmTNDS3cHboHMlkkos2XcTp/jP86Ic/xrIs0pkF6sIwdOowTz/2CBMTQ0gp6e5dhRap\np2PFJiYnE7zwwm5MU2dZbw/ve9/72LFjB297y9sJBWqZnlrgC5+7l0wyxe++552c3beTrT3NTIyN\ncO7cOT7zmc/wzt94Dw3N7ZQcScGyWbdhFWcGB3jk4R9z4vgR5hKjrFm/kvrGOtLpNOl0lnQ2T2Nj\nM44jSaazhMJR1q5fiWFKhOFw5z130dW7nOlEitODo1i2xoEXd7Nvz06W9fYwOrtIS08f/3zvv/Hk\nY08xOHCCgwdepKenh8nJSXRd52T/UYq5JHfdej2HD+5heWc3I2fOkMpkqGvuIFjbyKpl3Zw9c4ap\nmRkGB8/xZx/7BB1dy2hqbGD9VdsZTsxQ29pCtDZG37o1fOhd72X3ww/TWBujtaWJe++9l/lklkC0\nntGpBLVNbXz0Lz/FjltuJ9jYRNe6ja9uGH+J8ZqA0OcW0y+7iOr816sT2ZYe48cYFzpGbVQAKrLX\ndK/1pRCULIt4TQ26prGQWMS2HYKBkAfBuSB0hKZ74hDCi0oqD19lvRoYVFu1n1eV5ShnCdv+vO9b\nDU/6JsRxlLhL0SohAMd2WL9+A60tzfzJH/8Z97z5zSymUmimEqfIOxYF2yprkDvSwXFt1XjBM1Q4\nNvXxGGcHBnju6afYvu1iLr/qatB1AqZOY20NAdOgJh6lNh6lJh6jrjZGY10N8XiMmpoYDbU1RCIR\n4tEw7Z3txGvizM3OEY/HPHKbpZqI4OJKF90npZ33QF44710pD6vorvsP4ZOnLrgQKtwuDwLBZztr\nnvSnf+uVcZblCFXTwK/C9ulYwtcTx4PjhQua9InXqEImv3bcrdzn6kvw5x2JFMpQllX1pYsmXJAq\nRSM8CNqR/nv8kiyfrFVFxhNe0xZcBYl7vHC/bl11RXM9pnalrEvzctJC+BEuHiHQg+2NyvT6/zOq\n/aifkvDK3KRSEhQeqU3NvfDmpOKoOa70kBNvDsCTmnUQmoahiyUa6ngoCMInpSnipZAeIdCbWAFl\nmV6tyjEsizMhyn3DcVxVISAEsWgUIQT5fJ7k4iLNTc2MT4zS0tLMwkKCUChMT/cyYvE46VQKnCJd\nHc3Y+TSOJslmM0RCQUxD4+jRw7h2ieamRqanJunb0EcmlWZ2dkZBwqUSL770EulUkosu2komkeKF\n518gEAywetUqampjaLpk7ZrVJGbn2Lp1K8IMMjU1RTKdpaWjnRP9p1m5eiXD587w0p69rOlbzaH9\ne2mIR5mbn2fbpZdyZnCYZcuWszif4OCBg/QuX8l3v/dNokGT5oZmNq/fws9//iid3S1cd8MOsukk\nZ8+cwrELdLS3YdkWPctX0tLWg2aGGR86xYH9LxCPh9E0+PGPHqanZwXbt1+G6wgi0SgbNm2itq6J\nXTuf5NDeXdTFAjS0dTI/N8eRE6eJ1TWRyeSob+1i3cZNWI5NT+9yenqWk0qmyOXSlOw8ZjBIIBDF\ndSSaMKjxeEm5fIH6+nqcUoE9L7zA5k2bMAJBSg7kSxZt7W3kc1l0K42ULjfdfjfP7TtKOudy8cZ1\nuNkEQ6cPgxlhZd9GBk4PEQwEaKqNEw+b3HP3PSxfsYKR0Rk6W9vo7elhfGKUI8cOk1uY5/JrbiQQ\nivDg/f/Nqs2XsXpNH9Ojw8ykFghHwmTSObZsWM/q5d38wyf+khU9bVx97bXMJ1Js3HIpP398JyvX\nbGDV2o00NLdx4MQArhZmZGKOodFpLtuy5teC0I1f5+D/r8b5amjVbOFXy4UDr5g3fSVRlurjSqVS\n+bMMwyCVShEMBmlqaiGVSqHIOpUGDIqxfuEpkxK1qUs/f4qXrvUMsl/TU0Woe1k07j13/TxvlROS\nzmYIhSK4toV0XTKpFHU1cV5/8/XUNESQAQdXCsLhMKGg4e1vKpeka0rL3NQVkUoXAiufJ6AJauM1\nGEaA/v5TWPkC44ODmLpgYGEB27bJ5xVp5OzZswhdJ5fPkEnnyOfzZHJ5CoUCxWKR6elpPvrnf8aW\nzVtJLS4SDkcIBEJlln+ZZf4r3MPKKNdwXeD1/12SFUDziFd6maemyGcqVa7j66EL73qErCJCoURY\nPGuhQGOp4F/HM4TKeXTRfK17JJSdumoehuol7gCe2QMk2DZoOqqXiuutvSqGtdDLHdV86Nsvi5JV\njkoVq8D7Hi93Ev1haqhUSZkv4DPtFSfB79YmMMAT7amQTaucFC/PjxS4orJ2NSnK90cTLo5rKxlb\nT3NelXj9cs658JqVqA8UIFzvnqKQCCHQvX4CrieCpGZbrS3DMFRnPdvBdRzS6SztbZ0cOnzAQ/8E\nzc2t2LZLsWhRyJdIZrKEw2Esp8TQ0Dka6zZQVxshK20MXbCwkGD5smUUcml2PbuTDRs2EQqqNNPQ\n6AgNzS2sWL2GfMkiVluHYRjMTM+xbds2rr76au574H/IZFNMjpcoWUUsM8jmzZv5yU9+zC+efZav\nfPErxGIx1m5YzxM/f4b1fauZGBnk5ptvZXx0mJp4iNmZaQ4e7af3xX0ULZeurh56enu54tLLmF1M\n4RTzXHbJNjpaGjk90E9tbS07Xn8lDpKi4xKpidPe1kbIDNAaqGd2YoTJyWn6Nm5Flw5NdVHyuUXu\nv28X191wG1u2bOOnjz6GqbtctHUrNU3NDI9PEa6t5YH//Drf/t59XL3jBo4fPsIb7riH6fkEi5ki\nHd3LKEqX/uP9bFi/hcaGJlKpAv39h+ldsYx4TT25XIFiqURtTQ1OqaREmlyXxWQGQ8Ka1RsYOTtM\nR3cX0gzQ2FCDrruYIUHfhouJ1sTZd/Ag41PT5PMWJ/c9icTirXfdzeGxWfa/uJ/bbr+L/mOHmBgb\npjEe54lndiHMAE//7AHe8pZ38/DAUdb1rcZyJLFgjNV9fcTraolEoqzp68NyJB1tnfzi8Z9z9913\nUGoqMjs5wdzEObpW9fC1f/8yf/wnHydcU0dJ6my/6jrm5xfI2QXODpzjiksv5uzgIGfPDbFyzdpf\nau2/2njNGHBYmpuEV5dVhVff+Ksj+OrX/OeOZaObRrlky7btsuIYQlJbG2diYoKamhpqamJVuXT7\nVT7PU3arev3VzMv5Brz6e1UPTdMwTVNBtK6LoevkchmGB89RH4/x5OOPkk6nSSbTymtNZ8jns8zN\nzah8khlkZmaGUjFPLpfDKRUpZHOkUhmQBr3dvfzwBw/xH//xnzhS5U51oXKhihwmsKRUbRcN5dRE\no3GikTjC0Kmra2BhYYHsYoZ4JKp4Bq5SvPLV5RxH1Qif//3Ph9NfGXE5by2IC8/u+fMohPCiUel1\nxaqCxT1yliYBv64c0DVd5VcdiYtfHleJvqvzthU2uHLcXKfKORPuEiPsrxFwvLSCMuJqnisyoyqC\nFxiGZ+ykg+YT6zxmerlCw48uXeF9H+8zvfy18CJz6UH3VIvpuIocVzayEnVtHvkOF3QpsIWrPkP4\n0rpu2ZaqbvduVQMblTzQXZWn1oUnlqJLHFvz5gz8pm+2j0rIl+8BS1EZiaTSgMYnCy695245veKn\nPTTPAdeEhtQ1MHU0BwJmENtxCEdiDA4Ocv3113Ho0CFquuswjWA5OheaxpoNaxkeHuC555+jraWR\ny3dcz9mzg+TyE5w+e5arr76adDrNmTNnuOOOOwgaOg0NDaTSWV7ct5+tF23mF4/+jJaWJrZv28bX\nv/Qltm3bRqlUIJlcYPv26xgZHiKTyfDCC3t5w+23Mj47g10q0ljfxUJiDs21GD53lr17X+C6HTfx\n+a/+E3fdeQudRYumhlMcP36cD3zw9xgcGSWZWsBF0tzWTdAMo6FzZuAUAwPnWL9xLctWrmDfgYPE\nonWqlruuDgOHbCbJ9PQ4q9Zu4Nj+55kcO0fANGisb0Cp2Tk89fTTXHnVpczPzjI4PESzC2asgTe/\n872cO3OCr3z9XzH37iVihnnXe97DXCbHieOnWEzlWLuhgTXrIoTjcTLFPH0bNxGJhujq6mExmcIu\nFVlYWKCzs51CycZ2HBzHJqiFqK+tR1oFJocGKKUWqWlsIZPNMDw2wtTkKG2NzWSGR4k3dXDNlVeh\nlSQLw5KZU4dIZUsMnTlHuKaVzu5egoEw45PzuFYNlpOnc9kKTp04yLEDK5lLLbB56ybqQiFSiSyT\n01MsX72K1GKSUCREOpVh8PhJdB1+8Ysfs3FdH4889Ag7n36Mr3/lq/zDZz7HQz97nHu/+DWMWD3C\njIFZ4MSJ4/StXsHw0Blamxp5YfcQs5Pn4MPvfPlW9yuM14QBz2QU09M3UtVlYNXG/ZVgcX9cqLTM\n/3n+8YZh4LhLNwC/85btlCiVoKWlicXFRfL5LPGaKIFAgFLRvmC+VgMc16FMNqYSH75aCuCCTsl5\noaqUEl1o2J5yXCAQYGF2hmuuvJKAHsSWOfBEMhpqGnBsG6dUJBaLkcvlWLu2D2HoGIZGQyxKKvAZ\nUQAAIABJREFUpKaRUG+QpuY2ZueT7N27jy1btvKBD7wf2y5RU1NDNBpF0zTC0QidnZ30nx5g2/aL\nKRZyhEIhBCamGcQwgxiGzrFjJ+jq6iKfzaOjK+9ZOJRKNqapl+9t9Xeq3qiXlkZV5bCFXyrlT5Cf\nL39lac7znwvPiAgpy3r1UnjqXsKHXv1SJy/aRhUBuqDIc5rm6QoIz4CJJbl7X+bVdSvkS99o6oYH\nd0tlvP2OdqqkWfOMmZLhVc1C8MhoABVlAeko4p7fftUVeBG/l9LBN1oajlTqaEKzFczuRehKr95z\nPlxVfqhrlTkWKKdAl56xFBJbOkqMR/PIZEuidpXfFsL12qV6LHrPKdE1DQ2JaeiEvNJC5YiqNn66\nlKqpS/X6lxURl4qD5yr7jDdvQsMtl+SppIdrK9EW5XNpnoCOiyY1cFykpuapYJUwNZ1MLkesphY9\nYHL06HG6unoIBEIkk2mKhQKXXXkV+w8fYl3fKqK1NeQGLdL5PLoZYHJ6iqamZvr7+xkdn2TTpk38\n/OeP0du7nHe86x2MTU7xuuuuR6Lx0A9/wOTkJMePHSGZTLNy7UqitVF002BsbIxsJkNLYzNNDXV8\n71v/TtAU3HD96/nrv/w47/vN97Nmw1rGx4bYvWsnzz//PDXxFl5/00388Mc/4bff+1ssTs0zvbBA\n38YNlIBAMMjavjUkFvKEjRg14Rgy6LB8eTcT85NMz84wP5dm8/ptLF++HE3TOH70IIlEgtraGhbm\nZ5mcmGR5bzff+NpXWda7EtMIsri4yKo1q8iXcgyNTRAKKV32mqZm+k8M8IZb7mRweIpzpw6zZcsW\nPveP/8yf/+0nGTw3RnvPchzHYXRsDG16gr6+PjK5NI3NrTzwwAPcdNMN9J84TldXF5MT44QjETAM\ndCFxbJt0Pkl3VytH9jyFic3evftYvW4jw2eG6GhvpaVzJW4yB2YAnBKzoyNMDp5m3YY+3HyW+lPn\nSC/Msfe55+joXEax5OBiIowQgXAdV151Cbt2PsENt9zI+NAApu2QTOdpaGnGxcV2JadO9XP67AjL\n4zX83m//NkcO7+ab//YtQmaMj3zkI/zFX36csYlxbrrjTjZs3c7I1CKxUICCrb730NkTrOldzve+\n+wDFYp725qYL7mG/ynhNGPBsNkuxWKS5ubm8cSt9YlHuD3J+RF3toZ+/4avhlw693EhK6SmI+c+9\numpdaErnGUEgYGLbNs2NjSQWF5mbTVBbW0s4HC47GWXjUwFCy+i5b8ir9Zr963sl1KD8N/Hy121b\n1Vg7lk2hVCRWV893vncfh55/gbe86U2Yug+fR0DXCASCRENh9ux7EdM02LFjB0bAxNUEugm2N0MD\nJ47xxjvfQEdXM29797uwLEA4ZX35SDTMt771bd73/vcxOTWNHoiStwAkspRHygJIjcaWDtJFD7rU\nVE2+gcB2JcViEQ2Bbi5dbksiLQ8GlqKyeav7ZKMtiby8uvpfgn7pooyZJiW61+dal2oj11AGWfNK\n7XBV73NHSqSjK2lXITANE9tSRsfQdIq2hdAMwMK2HTTD9GqeBQHd8FeBKqjyDJOLqkO33VJVQw6Q\nlquKv1wNW2oIu4ghlOiIFBpGIETJKuA4TlnURxiqkYcj/Nyyp/5mariWi+uoaNNL/Hg14UoARyKx\npevl3HVVauU6XvMZiW4EQTOwPeUyXQhsy0ZzNaSjeofbThFNM5S+vOvn4ZVfpAsDIWx0zfsfcyz0\nQIBAwEDYLoIimtCwdeUImFLDsSx0oVN0LEVM0DQ0YXrXra7dRSJcC2lLAnoIiY5mGBTsAgWrREDX\n0UwDGxehOeimwCqVkJpQEL3n3GhAPpMmZAbIZNLk80WsYpHlXcsYHh5i5cqVPPHEE6xZtYbR0REE\ngtpoA4tzaaySZPXqDaQSSZ568mmCoQDScWisr6dUKKALjRuvex0H9uwmGg2RWEhR19BCa3sX199w\nK7ufepxdTz5BY0MrN91+M6Zpsm7jJh579Kc899TTJBMzSFfQ2taMYWjcftMtLMwu8tCPHuSK6ctp\nbm3he9/9Hy699Gp+8/2/RTafYnx4hKP9J1ixbh17HrifibFRujrbGTh1jhPHB7jimmuprY2zrKeT\nvc/v5Kmnn+Ut7/0ANXVd3HDzGkI6zM7NY5XynB44zsTIIOvWraPoCFpa2qhraoFIPQ2dK+hsb6d3\nZTfJdJa2nl7WrXLZf+AQ69YbyPwMTz/9MHWRCLGgjl0osmbTFnY+/xKZxBxPPvkTfvfDv48QknUr\nVjCbmCG1MEsykWBuYoqI6zI/PMzAieM0NjcRLBQIhkIszi3gaiYNpkVybJQXpqYoZC1yRWjvWUZb\nd6fSmtAEo1OzOGaAxcUMp5PDdNRHSeSSRGI11NbW0r2qlSd3H+Kbf/pJBs+cIPnUDHe8+cP8/h98\nhA9sWY9jtBBuTXPoyFGsbJbule0MzU5y6mg/UT1AU2MN4XCUxrpGamrC/OSRh3BtydjIJDfddBOn\nzpyjo6udpw8cpe/KJr713/dx151vgmKSyZMHmRk8yu1vuI1HH/4pwZDJirUbWb5i1f++if0v4zUh\n5HJyeEKGQiEKhQKTk5N0d3er6EarkFH8emwAgVL/8uuzzxdxgOpcXWVIKcsCIBpVx+BQ3TCl/Fle\ntOOXkxmGQSGXI5fLEYvFCIVC6tq843wo3o8cHMd5mZZ59bWAUl5bYtwvEKw7jqMU2vDKlTSNUqGo\nPidkqlwiFRlWx3IpFApEorXYrkt7awP3/uM/8Rd/8VHmFlIUikU0aVMXq2FqeJh77rqdpqYGHv3F\nEzhCI5PP0d7Syr4X93Pffffx+c/fy+zioiedaiGrYF4/Vwug+dVTKDY1VX2sXdvBclSaotpw+6Iw\n5YJ5rULS8uFvHxYFVORaBa1WR57lxiRiqSiIrybmrwsNCBrK2BmaYlQjXI8V7uDaSoBGCB2rpCJm\nTdNwShaGEcDSBKamecbQS/U4DtK1qzQDlsLn5eu1lfPnINAjUYqOyndnckWyqSxWyUXoJpFIhFDA\noqWpDqw0mmZg27bXUc9rOCMMbKuoSv0cR+nn6yZmQDlKpmn6sioVTXuhqhwsx8Y1gpRKJeYXEpRK\nFlPT8zg2GEbAY9v7gkY68ViM2to4sViMSDAEuoZP7guY0lP0s7GKNvlCiYLtEAqF6WhqIBoAo5Ag\nEgpStGxKju01bvH+T4Wg4NX+apqmShA9lEULmKDpuMJgeGiKsdFpMukCRjBEIBjEdtX9AnBkJfct\nNEk4GCIeV053Op1UWuexCOFAgKbGRoLhAMVshunhEQZPn+b06VNcce2V7HzuWUYmR2lq7ODii6+g\npbmdXc89w7bNa9n5iwfp27SRsZFhtm7dSiqVIhxVSJddLCndd9dmYmqGS664CpcA2XwBUwgefOB7\nfOQP/w/f+ObXmJyc5I8+8geMDo+QXJhnxcplPPfsbgJBhcgkFrIEg2p/OXfmDPNTk0Rr67jrrW+j\na8UKzgycIhYK8tNHHqaULzA1NcXa9eu57PLLmZlPkMsXWb1mHftfeJbt2y/m1Kl+SrbDlVdfQ1fP\nKlLFEg8+9ENuvvZa4kGNgy++xMlTZ7nk6msJx6LMLSQYP9vPxi0XEYs1spjJUVcfpaWpgVRikYEz\np8h6yOltt93G4cOHefThR3j/+34LzdDZ9exz/Oxnv2BkcoZndj3P1NwCqWRa3VfXoqGxDilVFYRh\nwcz4JAu5LFddcy0vvriHhvo6FlNZ0hYENJdAOEQ+k6WtpZ29+/Yxk5jntjfcxkD/CRpq4uRtjaa2\nTsxAgGPHD9DUVINTKLF+3QYMJ8+epx7j4Ud+hqYZ3P3GW/nWf/03n7v32+w9dphHH3yQP/rTP6W9\nNsZ/fPVehs4NkMoo5/D3PvYZamobuP+bX+Ham1/PyeMn6X9pL60dy+levgJNN7n9TW/FsYq8+403\ncc97/4jO5Svoam1l/95n2bfradav6uX48aNsvuQStlx+Dcl0ilWrV9DT081tr9vxy5FAXmG8JiJw\nv+e0YRj09PQwMjJCY2MjsXgEy7LKTT18QyalU8lXw8uMNyij7Of7XPyQTZSJVA4VTgxejak6ToJW\nMb6WZSEF6IYOmiAUChGJREin00SjUS/S8EqHPOUx3+kIBAIUrRKmF81XfWD5OvxWGFDFnD5vmKZZ\n3pgsxyYgTAKhINJxlaRgwFB5xXKEaxE2Aoq97brMzSzSWFvPxz76MT7zmU+z4Los5goeBwA0YTAz\nM0cul0ELBGmIBpkYGeT7//Xv/ONnP0s+kwS7hKnrCM3wyqZE2Xj5BsoR5+VYqUpj6BqGMMp5cV8R\n7vy0iVbNAZQS6SvJXSANUn4/IIRbIZvhEyJB1RxXzonrIoSDU7I9qVMdRypnwxSqwYgeMClZDoah\nEYrFkBLyuSIiGCBbKFGQRTLJFEZArYVAIEAoEkCTkmIpjyKtqbVkeNGhguYN1Z9bSoqFEomZBDOz\n8yTTKVw7iONILEdRyTRTIyAKtDQ30BgziMfjRKNRhKm01X2dAikFJak65Ek9iBYIIjUNyyri4JIq\nlFTnOFdScmzyhSLZQlF13jJCpNNpLMvBNIMgoqCDLQWm4aEeQRPbdsikc2TSOXR9riyhq+mossGg\nhvS6RxUKBYRhYFuKM5JoqKW1Ic7y9kYsXWA7Lq40lUMqQNN1hA66NAgaBqapUyqqLk3Fkk06X2Qx\nmWZuocTE2DyGESRa04ztOli2iy01Al6vAMe2MAzfebYpWJCZSWJZc2iaSpEVig6ZVJqW5jTdPW2c\nOXmK8aEhamMh2np6OHr0OB1tncxOTzE7MYGzpcTQ8CCW41K0JfX1bezd/Tw33HA9u559jg0bN9HV\nvYxkMk0iMYd0bQ7ufYG6ujrSiwu4eghHavRt3gxmiFQ6y6qVa9i+dRtPP/kMnZ3tpLIZJqdn2XDR\nZgq5LNOT49x+5/Wc7B/g/vu+y+z0NG3N9azf2MfpgZNcduUVjI0MYwSDjI6N84d/+Ifc//3vk8lk\nkK5LR2sbw+NjjI6OcuLEcd7z3vfyre98hze+8Y0MDw9z5OhxwjWNvPWeNzFw9BBPH3qJxuY2br7r\nHlau24imw2JintmxM1xx2XYWUkVCCynmE1OcmZ/CLhTo6+khkZhj1ZrVzM9M8+3//C/e/s53M5nK\nEixaLO/sZvTsabrWbODIyZM0d3aSsYt01HfiWEVOnzxHS2sj6XQS3dZ5afd+QnUBXnrpJVqbGzDX\nrKC+oZXZoQnaensoOpK5fBIjFOPKq1/H8f5jTE5MoOs6PT09PP/8Ls4OHCUQCLB562Y6u7vQjZCn\nqpfFtm3ChqYqB6TDJRdfzPT8PH0bt/GDb/87lu3w9FPPsePa13P69Clamts5fPIIJdvissuvZvfP\nf8LPfng/0VCYYmqGdCTC9q13Io0QJ08OoAuHqGly9VWXsPmiLXzxX77Ag9/7LmtWr2B6Psmd97yb\njp5eBoYnmJufoTZSx9TwBLe9bsfLN/xfYbxmDLj/U0pJR0cHExMTGKbmSYc6XlQcKEceluOWGeGV\nCLZyTumzhlERu1OFu5aNgc8OrpKSRGqYutocfVarrutohopGItEIuJLWWIyJiQnq6uqIxKKK0e7V\ne2uGWY7CjEAQx3UR+nmGjQq73a8ZPj/3XfVlKFkqeg0EPClUKdE1HaFB0bZwNcWkdy27XFccDpiU\nHBuha3zoQ+/noQd/zIc/8nvce++9GCGTXCZHY2Mj9TX1TM+Mk03n6F3VTmZxgS/c+3k+9rGPIYSg\nkMsRDAbw258KqfqHlxnafnTpSlyhCE0VtMQzzLrAkRqRUJhisYhdUiIwru2ocwkUQUu6Xr666j7q\nFXTE/4Pf6KYiW+uTsapIT9LrSS3cMrtcw1UiKMLw6tRddEOVfwlNxyCE5ZoEghrpbI6x2RmEZjA5\nPUs2q5rLOEAxX1CpAt0kFArQ0lhPbTxMNBYBIBxU5L2C41DIFCkWiywupLFLDrbtkkqlyNoODpKA\nGcKQBhqSUECAoVNySrhSY2x8hlHHRdcF4UiISChILBYjGgsTjUYJBEJIV2BGTIrFIuOJRfJ5VR2Q\ny+XIl+yyBKzjOBQtG0dK1ZrSzaDrGkFNxym5GIbqAqda4FZY7KZuYIbCOI6NdByKxaJCTVDokE8M\nBBBmEGGpkreAIUgl00xPTzOdSBIOCIrFoqeRIHEcG9M0CYVCBIIxdK9EYHFhnkK+RNGysV2XVDZH\nJFxLrKYW15HYrpJFNQM6Ohp20SqvN/AQEW99BoM6ZlBxMObmZpBYtLU3MDc3y7nBAVYtX44ZCzMy\nM01dfQ2HDh3ixte9npZ4A8fH+2mMBuifHiKVTpArFInXN9NpZykWSxQKRZLJNFNTM0SicbLZIi0t\nTRQKBSzLIplMMjY9SDhey6YtF7F67ToSiwuMj49z950f4gv3fp6LLtrMocMHEALWre9jeHiQts4O\njhw9Snt7J+/+jfcyPjLCN775b7zn/e/nK1/+GnPTM3T0LOMt73g7BdthVd9aGhobeeThh7n77rsZ\nOH2adDbHZZdv4diBPYyOjuI4klQqg2FoXHH55axeu4HBU2eJhcKEYzHe9I530NjZw08ffYzerk7W\n9C5jw8ZttLb1cOTYc6TSWU6fOYVVyPKGW24lsZBkfiGDce4sX/zK13nP+97Plg0bKRQthNBorKvh\n37/zn/zBn/8Fxw8f4q4VK6GhnkBAY++BA+C6dHQ20tRcz9n+QVauX0e8LkihUKD/2EGmJ8eZmZsn\nUtvKocMHWLN8NWuX9ZCZnaOmNsbmVSs4NXAcUbKYHBli9bLl9J88RjQaoaOhnZHTUxihMNlSiRXd\nrdxw8w5WLe9kz8497HrqGabzRa43DK655hrqa+IcP3KAn//oEb7z9X/hmoEdHDxwhDXLWvnml/8Z\nO5djw+pVLC6OU9/QTDFboKm5jvGxAbSAiavpJBcT3HTj1bhWhk9/8hMcPHyIP//4X9Ld3YNOANMM\ncezoCZrru9i0cTupdAIhf/12oq8JA67rOqFQiGJRKaO5rsuaNWuYmZ0ilUrR2tpKMKgibsuy0Ewd\nXTMR0u9LrM5THZ1Vmoh4RluDanxa01QJT3n79yNFTSlJBUJBhJQEw0a5eUcwHMXyWeClEk1tbSQS\nCSioWkUNVMTuVcAWHQVp266L8QpkPNV05dUTuq7rEgwGAShaFgEPkQAlsyoMFYFLKRCGSVBopNNp\ncjlFOJOOzdDIJHe/6S4amhv5nd/5Hf7hHz5LR2sbcxOTKjVQKODaDkHN4M/+/nO8+zc/QHN7N1PT\nMwSDYUrlshzVIEPJdepei0lAuOiOQHMFrqZga//7qvnVMQJqww8FTSzLolTMK5a6VOfyy39x5ZI2\noRca1eptPlFNjWqugTffiolWNvYSiasSzViuq7qJmWECZozFZI6DR/txBRhmkJnEIpZUUbHSdRfo\nZoRAJI4t1fzn0kVS6Tlcu0ggYHj6+jWA4nIUrRLFYpFQJEKpUFCMcS2IGQqA16K1ZGlecw4NwzCR\nbglHCyICYYJ6gEIhRzJrsZjJoC1k0DQwdYPG5haFUAlVBrm4uAh4JE1HEgzGELoSU3GkjTAcgrpR\nTrUIj8CHdLzmFQJHyiWYlOM4ZW10TdOIRCJeakilbZaQRXUDhIXmWkhXohs64UicqYWiUsZzJZFA\nECV44xMbs1hWukwqdV2XUDCIYUZBNwiEoqoqwK4IIhl+Hb+UGKbnaLtK4tZyPN16Q6FFQUOtt8aG\nBtKLCwQMk7raWrLJFGNjY9TU1TG3MMfY1CSNDc0cO3qUTevWMzE+yo8f+gF9mzfT0ljP0NA55saG\nWbO8hRMnTqDrOkePHmd8eo6Nm7aQzRUQQicSq2FqcoZsweKq193I8Pg0w8PDyrAXS5w4cYJdu54F\nIBqNkknnmJ9PsOeFvUxNj9PZ3sFFF2/nhef30txYz9ve+U7u+8EDxGvrueeee9i/bz+9q1YzMDBA\noVTkpf37ef2NN/D8s8/xzJNPsmnrVhpaWgkFTUKhMD/50cPEwhEa6xpxgWd3Pk+p6HJoz36yxSw3\n3HI7R070E5mYQrolRgdPs3FlD4VSkYNHjpNKp3nu2We47nVXcfml2zl6pJ+apiaYGGRkaAjhSrZv\nu4y9ew6wrm8T06l59h8+Qn00gqlrfOnef+TO225BFnOMTEzT27sM09BIJ5MMnjtNKFpHR2cntTVR\nFhcTlGyX+fl5mlo6mJ2aBGmTWpxm+NxpLrpoG0ODJwmFTeJxk+mpRXS9nqHhswRNwfU7ruX4yUHq\nm9spuZLlLS3kckkEBW64+SYGTw6y54XnmC/ZPP/CbqYX0rS0NtPTXEd3VxtPP/c8LirwsRxwnSK5\n5Dxf//IXaFzWSe7UWS7bfDEd3W20dfaSWphhQ98avv/A/YxPzfCpv/tbrrvmBj7x8U+SzdvkLY14\nPE6hVGTr9i2k8kVy+QwEBS/u2wd84FX3/v9tvCaEXJLZwiddVzXXsG27bOTiNTE0TfNqsiXhcNjb\n7BwsR3rtLwVeL0yq5UGE0JUREQKhaWrDFnrlvULghWWqhMc7jzpWw3GV6IsSoFDHFC0LqWnkSyWE\nplOyHYLhCJbrMpdI4AqBHghQclxKloUZCFIslQgEg0oApur6KtdL+fyv9NB0A4mqYTXNQLnFp9B0\nNN1QbF/htcB0JH4r1Wg4gus4iowlBJlUmi2b1rNs+Qr+5q/+miuvuJyamhhf+cqXmJyY5P/84R/z\nrW/9Jxu3bOG663YwOjlFJB6lYJUwdKNcYldmCHvCGz57W/NYexqapw/u9/VWEZljWSo6FwJT1zF1\nHde2PWa4VtYT99tRakIovZAqI65+98uEKH92tRFXt11TUbZeKZPyiNhY6EjdxEZDaEE0M8rMfJaB\nc2OcGBii4AgyuRIFG2x00AMII4gUOmg6jvX/uHvTKMnSs77z977vXWLPjNwrt9qz9q2X6urqvbV0\nt5CEZTACIyFLSJqxYZDH/oDNAR9xfAwzNh4zwwweZmETCARIlhCSutV7d/VaXdW1V3XtuUfuGXvc\n9Z0P743MrBYw+PAFfM+JU5FLZUbEvRnP8/yf/2Ic/cI4MlO+lrhuCsdyEoKXIAyh2fJpeCExCqEc\nI5USFiibWCu80LxWSll4gFA2USwIYuMpHkSaKBJEYYwWYDsOyrLRQqIslyDSLCytsrxaYXm1SqPl\no2wXoWzCGGw3nTjmxQRxZBjawoLYZAHoJJverEGSax6x5tEShut7aYQwBTZBrzbaHrfjbsEQQuMo\nwlLS/H0K0EJhWy5OKkvKSZFOZRBakUpnkY6LkjZaKYTlIBwHaTsgFGFsWOVGM24ZmoSQJDYJptGL\nY+J43eXPtm1DhiQh0sUmE0AISRTGtOp1ZmdK5PMFUhmXm9dvkM3nKRaL1CoVDu7dx1tvvM3FK5fZ\nun0zzVadpaVlJidnGejrx2+sAJqFuQX6BgZAKm7dmmBicpJcJsOtG7doNip4zRYjm7fw+pvv8PCj\nj/G973yXSxfOs3vXLixLcuqdk3z0Yz/EzRs3uHbtGvv27aW7q4tGvQFocvku/DDi/vuP8zu//f9Q\nr9W5du06H/v4x9m2bRu3JybJZLOUSvMcPnKIns4iMtZcvXKFxx9/nEwmy8pimedfeokLF87z8IMP\nsW//fr73zPNMTs0wtnOM8YkJdu7ezfDmLfRv2sTs1ASH9uyitrrImydeYd/dR/GB1ZUVfujJD3L+\nzFssLi5hpXLYtiJlS955/QQPP/IBFleaLFZaXHjvOksLi9h2mmJnD7YIWJyf4datG2zduo3x8Rk6\nOossLC7yxokTbOrqIRSKTVu2cvPadTKZHMWOPMQRYRjR3dtHT1cnS8sLFHt60AJefPlFij0dnDt3\nFjeTYXhkK41ag2qtzsTUJMWuIjdv38JrtXjn1CkatSqvvPwiv/4ff53HH3qAanWRs5duMLNQ5oHj\nD9HbnWdx8iZdfZsIY0E2l+fk6ZNk0kby9k8//zkunz7F1dIc+47cx7/6+V9k655DlGsRfYUu5scn\neffdq5y7PsX/9Gu/Qa6jC88PufLedRYWFg36trrE6tIMt2cnuDlxDduVbNsxzCPHjv7y36Z2/p0o\n4EuV2pfbbxYbpTlB6JNJ58hk0tRqNebn5+kbGEAoy5Bz1mjf6zfd/uPewEbX0uy/14E+ucHJS2/4\n/+aINcRmHEm0iMmkro1ftbIsA8lLMwdatk02l2NpeRk/CHBcF8cxOlPHcgxr2giqaUc0tquPVOqO\nzwsh12DpOwlQ7e8xumHbcYxntRJoFGGkEdIyr42OCKIIqWySgGaUFNiOw/zyMrvGdnD0nqP80i/9\nIgf27ePdd0+zsrJKaXaeY0fv5x984mNMTEySSjv4gQ8yRocBCm2iJjHFtc0cX7MwjaM1bXVbzyzE\nhl32HbKgdRKfEMYtSwgD17bDMcyZ2ngu1wv2mhuZIjE52TDxJ5N2HBtzlaR7MsiBZaPsDKHQxCiW\nluvcuDnDlWvjlOshfgRaWEhlEWiQliFRtffNYWiczSBCSYGbtpFS4yjjJqaUyVR3HcdQLhKpU6gj\niAVSmAIfRKBsG0tKoiBCqAgdBthSIoU29wUmqCPZDTspG6lMII1ZHwksy0EpC6Vs2jnd7SYxjo3Z\nadvuFZE0U1oTx1Fis6pBhybKVGqIQywpiOJ1e+M2qbNNAtV3+DO0Gydz/hwpidvRstI0z5aQECYu\nc2hsKfC8JkJCrCNiYoLAMw51lkBZiUJAaGMTq8wKIYh8zNM25yDSkeE+CGnWR22injYNY6w1SpkQ\nIoThNDiWJJ9LUyrNEkQBhY4CczOziBjm5+bo6+ll584xtIJSaZbOzg7qtSaFQhcz09Mc2DnEwtIy\n4xPjHD16lL7+QdxUGtdxuXnzJlrH7N65gyvvXaVca7CyWiWMNfcfO8bkxDh7du3iypXv3pWUAAAg\nAElEQVRLnD1/lrsOH+GN19+gt68bhaDVbBIFAWO7d3Pm/EWCIKQ0V+LlV15h2/AWgjDCCwI+9VM/\nxc/9j/+cwwcOMjM1zZM/9CRXL13mxMsvMz9bIp3JUm80cWyXr33964zt2M4XvvDT/MEf/hF79h3m\nqY9+nEsXztFRLLJSq5Hv7GJhbp7S5DiXz5wi8lt89at/yPHHP0Kuo5uJ21N05TKUpqfQuHT0DNHy\njdrg+e99m5/41Kc5f+kKfUODPP6hD9BohPQNDJHNFjh2ZA8pJXn+2e/TaLS47+gDzJZKpFNpBnq6\n2dRdxM5lmZibo16p0d/XR6NeI5tyGBwc5ty5C9xzZD+XL1xnYX4VqW36e3vpLHQQR5BOFXjhhRMM\nDo0SBpJ0toNWy2NqZppiVzfDg1sY2tTH/r37OPHKq3zw4Qd46aVnCHTEJz/133Pw8BEKBZcb59/h\nzKX3+NwXf5aFuQVeef0VOtMW2bTL09/6BhkpCYoD/Mtf+hVqTQjJs7hSpStj89xf/BlXr9/kZ37h\nV9g2dgBhxewc28nW7VuoV+vMzc3SkU2xsjTL+OQUH/7QhxgaGcEL4YG7D/43UMDLtS+LdjAxpmOO\n4iAhg5k3i46ODpRlMTk5gZvKrO1AIYHupCm2QiVGmMroZLXQ7fdv1n8HdxbvtYxhQCSWkDLxaJbm\nZ7fVKO2CtC5RW3+MxWInYRhQr9cQUuCmDEtWSzMztqFMoVQSChEbOdH7fkf747XPSdN86PZ0Kkzu\nkxYQR3EivTL7YqXWWfNSSWyhINJo3UIlu8FSuUZvTxePPPQQX//jr1JeXMR2XT7wwQ/zU5/5SW6O\nT2C7KcJECqdDsKQNGCQjijVxtN5wGVb5Ommw3e2ItddYI0ScTNZmb24lMishwLYMYBv6IY6dQUhh\nioSOsJICb/bjG3atyXO1lAad+JhLiKMIZSlCHSNFiJTguCm0shCWQxDGlEpzTM2VuXW7xMT0CuWG\nBrtApGxiaSGVMjpxKZNLwiAEOmnCFD6OMNppSYRr26TdFFFgHm+7wLUtPIWQKKGSa9BMqUoYgqFB\nfzCMXEHbOB5LKlxlm0ZFRSipzXQbRsn5NPpYZacgilBEiBiEsI1kTMcIHeJIhSVMEW1nkQkBQsYo\nqQjR5lpMri8hTaa2EiCVRRTFSKmwpCSOAoQESyhzLqVBD1qtJm5KEYRNQh1juRZhFKBiYxvcCnxS\nsYelQlrNesL1iNGxj9AhYdBCSYWUlpHvRaZZFAnLX9opQhEZmaeOkLa5ntASHUks18ZOdvJeEKIs\n28hEhUDoCC00vu+bVD8nRb6QRwrBytIcvV3d5DNZY7OKxHIVVsZh974jfOOb3+LQoSOsrFS4/777\ncFVEde42EQ5RGBNGMYNDw1iWTb3eIJPJ0N3TzeVz53jowQeYLS0xsn03J0+do1GvUl5aoHdwkNLs\nHOO3JxjbtYdr164SeD5Lyyt4zRU2bRrA81oU+4Y4fORuRgaHOHPyJNt2bOWffOHz/Otf/CXuuucu\nzrxzkqDVore7C93wSbkOCMHV69eZninx2KOP4wVNXnj5Jb70P/wcb7x2ip7eAcb27OLq9StMTtxm\naPMIXQODTM4ssDQzS0YHFFMW5989A8plz11Hee6lE1gqIufEnH/3JF19ffQOjlIqlVieK1Gaucbx\nxx6iVK5Q92Bxvk5pchK/ETI7MUOjMc3VGxeYnp3mnZNnuOfe42zfOUYqlaK6skBleZHlZotSucrm\n4UGmJ8aJgoCl5WUsJUHGhNjMr9Y5euw4ncVOWr5Hd38Pr7z+Gn2DW9i7/25y+Rxj+w5Q7Omh2azR\n01Vg3+6dbBroo+VFrC7VOTi2jdrSJA8cP4YfOrz4ymvc9+ADbOnr5sUXvsvkZInunhEmZma5cuU8\ncwuz7Nq5k0989IeZGJ/lS7/8q1iFblabATMr84xt6SRjh/ze7/wWe/eOMvbgRzh75goH7jrAjZtT\nnHnnLI6G/Tu3k0+7BD7sPXA/QWQxObNI2i3ywD27/v4X8PnV2pfNm1jiRiWgvbuWUgGaRqNBOp0m\nnc6ysLhEZ7FrDW43Ui691oWzwRjCHO0fqjfcj9/39fXjrzNeEdgIYYGWyd5WGhgVhe+FpFNZHDtF\nuVyj2fDI5zoI/MhYTCY/u73rE8oU8fauduPvf7/8qP2I2pyt9tRrJnjWYO32a2LiKE3Bj+MQL2ji\nuC6ZTIa049L0W2SzGT70wQ9w6uwZbk9Ns2X7dh566DjVMABbEYqYIIqwbIswipK9cfJ6JxP3uiSM\nBLtOdsy6fTOwu8bok4UQkBCfZGL+IUSEY7uIZDKL4xDLlmvTLEQgI9ARytY4ro3t2CjbBrIoK03L\ng2otQEuXCAvbzoCdo+5pyo2I2bkak7MrjE8vM7NQNpGEGiwnjWUZfkEYG+fxOEnxWvMX0KaotZEA\nIdQanBwLCPyAKNKECZwbxcafLIrjpDCutXvmPAkjj9NrzY1hc0uZyCLbu3tpnn+YNEs6Wk8SUwly\nE+vYNDBx3G5/iXWSD5ZcA3dK7pIVhFRmPbTWiBpdt4hBaIMsGchdIaW5ZpWtEoJbWz2BKeJSoaRl\nin9knrCMwJEKpQR+5BO0aiitDBE1sWYV0qbZbGFZKdMIxxFI1lLdRLJmCqIQISxkDJYS6CjGkhYg\nsZRFq1Uzr3sUk06lCAOfKGiiI28NUjdPO8YR4DerKBHjey0WSnPMzZXo6+1nx45tzJVmmZqYQMc+\nxWKaudIUHZ1FWs2YYkc3y3OTXL36Hnv2jLG4tEBpfoGOYid+GFJr1bBdm2Z5kVMn38QLm3QUO9iy\nbYTZyRtM37yCoz2GhgYIg5B9e/fgN6o0KitsHeylo1CgWq2BsHCyeUPgDVtcvniOJ554gsFNQ0xO\nT/Nbv/V/cejAPuZmZ5mZmqbWqGDbFh1dZvo8c/4ClgVBHPLumXPcc/fdjN+ews3k0Ugy2TTl1Xly\njkMUGPe6wGsw0NNJqTTHtckp7nv0cRotQeAH5DJ5yitVcvkutLDp6CgidYuRoU2srrZ47/YMm7ft\nolyuMjzYx96DB9k+NkIrqoBw2Lb9ALmOXpTj8uqLzzA0PECrUWO+NEM2bZEp5ClXy1TLDerVOkJr\nbGWTyWXZtm0Hr77xFvv2H6Qzn6eyssyB3buZmLxNNpdnx+5d9A70M7dUodxo0Wh5TE5NMjg4zOLK\nCpeuXKW3t8hqtcam0RGefukF9h05zIk3TnDx4hmOHLmXZsPjD7/y2+w5fJTtu/axuFDi2tVzZPw6\n+/ftxUqnePrN17jrwSfJWB2kAhfhr7B78yZ+9Vd/mVPvnueJpz7MoXsfxl9d5vqlW1jaYWjzDvpG\nt+AWOwkE5Ivd+IHP/OICW7ZtxQ9aPHDPnr9VAf87oQO/OLm49iDavlPt4qXaECxRsotTBEGEFpLF\nxUVs22ZwcJBms0kQhetGGX+LYyPR7P3//mWmMG1yD0KYqWiDhrzWbOCFAYVCJynbwfM8hBC4tkMU\nB8ZdawN8/9f9Prmh0Lf/jdBrVqsb9eZKKVzLptIo06xWuHnzJt/+9rf5/f/8Gzz14INIy8Q5nj59\nhhjNffc/gGsrSqUSOpeht7cXopj77j3Kz/7Tf8ZKtUYs1j3qhWA9rlPECZlQIlX73P1galzbXsQ0\nFzphHSdJXsRYwhSwUJv9F0iksrHsPEIoqvUGN8enqHuGoez5PlIqHCeFki6eFyCUItRGIx/65t90\nOptAqwZWNY+nLU0jicFcf52N29dfbeOrsc0OXmqQEVIZpzwdbjClSZ5nG1EBQ7LSWmMncLSUECT7\n2zCI185jW8GwxgdRKsn8itdY4kizI1e2nbzhmcIWo4mE0agjBVZkZJciWTO00RKtDRojIlOOhVDE\nKEIEaEUkDEoQR0aahTSNoIG9jemRFKADH0dZaC2IQtBxiJNyDDqhwQ89qvVVelwLGfrUvRbNKEK5\nLl4Y0dnZiWW7SIx/fxybtUqzWTfnSFpI20GjsIVYI9MZNYREaoGyPaRUTE7PMrp5mHp5hYWZ2/R3\nd1Itl/FRpHMFGi0f1xKkHCNjW15YJBaSdCZLJpPhypWrrMyVkAq2btnO1s0j/MZv/h88/NgHqdRb\njA4NcPXsc8xNTVDs6mZ0yw5eefV1PvDER7l2/SaTM9P09vfQqQMGOjsJEbx66h3233WErlyeqWvX\nESIglCkilWZmboFPfvLHeP3l55ibuk1fXx+2k2Zo8zZqXsihg3t57ZVnmZm4Rf+mEYaGN5MrdNGo\nNvjm17/Kgw/cz7e+9V947PEH2bxlO/Pzy2zdsp3Kapmnn/kuqUKGq1evcv+xh3n8Ax8DlaJSq/PW\n26+wc9sQjlRs2TbGufMXefDYfbz9+mtcv36dnfsPEmMTWjYyjikUO9EIfK/FammKrnya7kInN27d\nZr5S5+BdR+jp7UdoycjQELcnZ7h46TyplMvuvfsozUyzY+sQceRz+rUXePONk/zEJ/8xS0tLOOkU\n06sBH/nYj9JoVpgan8BSgnw2w7mzpwijiB/+hz/Cs88+w87Nm4mDFi89/xwH77qbLTt2slSt0PJD\n+rv7yGU70FpTyKVpNipcvHiBKIoodPUwOjBAT1cHjcYKExO3eO77T1MsFpmZq3DgoY9y7rk/4buv\nvMFv/e4fsHVTD//Lf/wPvPj9p/nZn/4cJ0+/i8wX+eEf/++oVhrEAmo3T+P5dSYmJrh9a4r7H/wA\n71y9RiGbws2mqNSqPPjQcdA+jtTcdeguzl+4SUdnL5cuXcJ1jQfDf/6NX/2rp8W/wfF3goXenk6h\nTTTSa0QmJZWBRZWdaLMFyrYJoojh0RHm5+e5efsW3d3dpFKptYKx8fjBiXqj9OgHj/d//x0sWx2/\n72PzmKUUhHGE49iJXt00EZlsGjuwqK2uEKZS5PN5oiDEazWwLON2tdHTuS27WicBa9qBKgmCm9w1\nd+w2uSyOkmYASgsLTExMUKnU6ezMk7IFw/2b+Nxnfordw3302jZvvP46C4vLdOezlKs1SuPjBEHA\nJz7xCcbnZ4ljYwbTLJfRYWQgyqR4g2GTx+0JNZHhmQIRJcXuTpY4GE6DECqxhRV4QYQQGsuyQUaE\nGNjZcR0sW+JHprCV5peolBuslhtomcaPBVrauIUskR8QxMmqQSkiJFguMTHZQj+tVotK3Tcwsi2T\nIBBBqNfJd+3Xfm3iloqNioW2Qcza9xqvUDM1hhE6cUNTwqBFOiHZ0TbxiXVifPJ+pEWtydsSy/g7\nrr31vX77pxoUQEgzUbbtVjXGBS0kJI4jhEzkXVqt+RkAJhKXCCnbBkKYKR5l+BRCEwujz3Yshyj0\ncC1FqENE8lYhNLjKJgp84sAn8GtY6TS2nSOIfISIaQUNYjSu7SBsibQt4mZAGDYoZFME1TIijrF1\nRFDXxLZLOlNEooh1hO95ZBwHPwqRSqCFyQDQUYSWxtVOCo0kIo4jAr+B7/vMlSZo1VcZ6O1Ehi1q\nS7OkXZtcKsVUaYpIC9yOAq3Qo+X7OJag3mwQWBYL9TrdxU6ieoXlpQXeu3yRbCrDIw9/kMtXrvLE\nD32Yt0+ewMnmqXse3baFk3IpFDrpyHdy7Ogx9lYqnHr3NIOjIyxMzXB7epLunl5Ks/NkRtO8d2Oc\nnp4iQrQYn73C4OYdIBWNwPiJr9bqjGwdYGZhmeHhEYYHh8iksgwNjWC7aXp7e5mYmGFpcYVapcro\n6DCZTIryyirLuSW8VsjK4hKTN42s6uWTb/ITP/GT3L41ybtn3uHo/Q9we/yaSSxbWaVWr3D1xiQD\nAwOcOHGCt996i499/ONMzy0REXHo3oOUyyuM377FyOAm8rkMK0FAOt2FZad59+x5vvwr/47vPfM0\nRw4d4NSZC1y9fp1NA0M88tCjlMtlTr59glazQqMyzabeHnaN7eXZp5/n5Fuv09vbi2w69A4fYrHa\nQntGOdPf18Ps7CzDIyP09nUzOzXJUG8vzz7zXXyvzv0PHEdaDp1dXWzfuZPFxUVeev5Z/GbArVum\nFszOl1hdXSabzXJ7cooPPPoYXVkXETW4564jPHjsQd46eYY3T53m8R/7PD/88Y/yzMsnWCpNMDbc\nzcUL71Es5Nk+tovvPPscn/7kp+gs5Bko5rh85SyFtM3FqXkuX36PX/43v8Lho4/w6rnzBEFAvV6n\n3qhx6+ZVRvuKNCvLfOdP/pxMvocXnn2B0A84et89VCsrP1B7/muPvxsQeqVhHkRC+BGsJ5IZFrj5\nbKwNLKmTCbPleeRzObLZLMvLy2te5m0zlf+/46+Dyt//9fff18lus/2xlAbOazu2tYl0AoHruLi2\nTeD7VJZXyeUyuI6N73lYsh22AesQ//tv5mvtffvGWxD4NJsNHMvi+rVrvPb6CXLZDB2FPMMjW9i2\nbRs7tm4jn83SXeygI5dj374DvPPuaR585CH+19/837l48TyrK6tYrs1XvvY1zp4/wyOPPsy//oV/\nxeHDh2h5Lfw4Qisj24mjkEibN0/NhjxpzdrHG9cSGydx0zQZ+DbWAiltlOUQSUUQSYJYEuOwUq4z\nM7vI5Owi41Mlqo0WsXCwUlkiYVjgcRSDsEy5jCVhrAEjb5LCwnJcbMdt53IQxsYbQEtQlmPIitGd\nwRkiWRO0oW1zjt+HyGgTqyERSNuY+0ghiBOPdMl6E9oOhJEJUQ9EEiCSvC4JerM+Hd+J8JivtR8X\nINb9C6LIT/LFSZqFtTJvCGNS3mFxsDF1bK0RlOtmR6GOzc+XAh0GePUKrmW4BmEc4VoWoe8RNGpk\nUxZ+vUyrsUIuncYPIlLpHLHwUY5Fo1FFSrBshYg14WoFohAhJbatDGogFHEYEwUBQRAQRUaR4Lda\nZFwLHfpYUhJ4TUQco+MQO8kwsKQgajXxm3WazRV0HNHf2021vMzEzWu4MiblKLx6FWVZ2I6N32zQ\n3dmBm3JJZbLowHgRpNw0q+UySggKuTSFQo50yubMmXfZuWOMd8+eZte+nQwNb0KELsvLi1h2mtnS\nHI2GaUrDIKRWrXHx/AXclE1HVw8DI6PML61w6vQ7HH/gOG4qxZl3T3H/3YdYWVpianqKwU3D7N+/\nl+XleSbHb7Nj115S2QLXrl8nn00zNXmb6akp0pkMUayp1Rr09/YztKmfZ5552qgTlCKKYGzHLkIv\ngCigNDPLvoOHKM0tsG3bNgqdBVZXy6RTKRYXFkil8jx4/3Eyrkshl+Wb3/wmW3eOsVJv0DM4yu4D\n+7lxfYqFxWXy2RxbBwcJWzWUkHR39XL56gUuX7/O2M59dHR0MNDfx+btW7FSDulslonJCZaWFnjo\n0QcIwxb1WpnV8hLTt6d46OEHmZmbwnYl+w8cYHT3PlQqxWsvPMf1G9dYXVlhcNMmNm8e4ca1a5x8\n+yRH7zpAs1nm8pXzdPf0cOjIUd555yxf/7P/wmsn3uDgwQNMjk+wb98+ytUqu/bsYcvWbRw//gBp\nV1H1PIRSnD93jnq9gRCK3/nd38fK5bl28waf/eQ/4Nmnn0ZHIe9dusirr73OUx98mM5igZdOvM4/\n+snPYllZhvs6eOiefXz769/ga3/+Hb74Mz/HwXuO8fwbJxke3UIu3UV//zCjm/dw8Mhx+gdGGR7Z\ngpvOcvd991IsFimXV2hUyhzct5fjDx//+78Dn6s2vkzyvrku/RJrBJ9Ya7ODS6bA9vTX3vnGWtPR\n0UGjXqdWq2Hb9prRxF+7z/4bfu2vug/rE5UQBsKUCYms/TlLCyI/QIiYXDaH4zosLS0QxxH5bJYw\n8s3PiU3ghNjwe9rTWbtYR3GU7PrMpBXHhgmdzaRBaAq5LLt2j7F1y2a6u7tw3BSh79NstKhUlqlU\nKly/Oc7o2B4aQcSV27f46Mc/xtLSAiffepNiTw+f/sxn+MOv/REHjxxm09AQ5arZr4VhRBD4SB2v\nEdiEeaBrr0G8FjoS3/H6mJsAJRBKEYQRKEkqlUEjWS1XuDq1xExphanZJRaWa5QWyqxWffxY4qaz\nxEIRJFB7GIWI2BDG4tAUSm2CIxHEJL44NOpl0BFCmyjLOI7WMtN1onmWyjibbTw2RtpunNI3Hpay\nTSOgFOl0CmJtfMPb123SaLYHeS1NvKaU6+c1TkJSDHFTJ0x3TZtJfQcqwBod0DxGAXHkowMjaQxj\ns3yKkkbJOJ1plDaoCGzkVKw3LWvKAMFa+KlC06qv0igvUF9dpFDIgY5wJIStOs3VeeorC8g4IGMb\nnoqSKVqtmFZQJ4x8XGnh1+pEno9SYMuYKAyJtZGYhX6ArSz8RoDvG96ATB6bLUkQpdBoR6LQFHCB\nQeJic54jv4XfrICKUTKm1WjQ3VUkm3aYvH0Lv14j7aaRto2TSjM/V6KQsgFYWlomnXJZWS0zODRC\nd7Gb69evs2fXThqNOumUYveOHVy/eplLVy7Q29NDIdeJVzU8h5SbZXWlwtDQMKdPnmR4dJgoDhke\nHqDajPFwsNJZhoaG8Lwmly9fYnB4FJuQ++46zJX33mPfgSNcv3Gd82dOU8xlqKysEsUxY7v30qjX\n6OrK887bb9HX28PM3DzDQ8P09Q0QhSGtRo0bt24Z6+mhTWgEmXSORq1GypY06jXefvcsh++6h5WV\nVXp6+ylXyuQyecZ27SKTK7B1yyitRoO/+M630DrmrqPH2L77AMceeoQrV2+RzmTo6+1FEVJZXcSW\nmt1jO5kYv80LL77Al/75v+TkuQvs27uXdDpNpVqls9hF10A/gddCEvP222+wd+9ORgY3MTs5yfZN\no8wtLnDgniP89u/9Lvv37eXatRsoR9NV6ObDH/4wA/0DTE5MoKOYVrPOzq07uHTuFIMDPYR+k4nb\nk3z7O89Safj0Dg7z6Ic+SFdXN4VcHt9rJQqdmLm5OQSasW3b+dCHP8SWrdvBcrl45RpnTp/BazUp\ndBTwvSqPPvIYCsV7ly5w8u03kBI++Y9+hD/82p9w6K57+chTP4rjZpgev8x/+tV/w+XrN9m6/27+\n2b/4eRbKdSphgAibpFNpbt0epx60UG6KuaUFgjiku6+b6bkSo6NbePSRx0i5Lo1GnYceffDvfwEv\ntSfw5NhoArK2C1dqzTRCJIU9QiMthdAGMszn8ziOw9LSEvl8/r9qwv6rvv6DcHqcWHSasAWSece8\n0Zv7UgqTY6VjZMLo1STSHSUpFApEUUC9UaOzWEAk5CTDszHkozgyHs9RGBq4lg2TvmWMOMy+VBMH\nAaHvAxpLSerVKl5ipZmAtKSzLplUiuFtO9GZPFu37uA3fvP/5DOf/hRXr1zinTdfR1kWn/nsP+H5\nV17g0UcfIZvLmGIdBihhEAahk0ZDaEQSkNEeAtf38/H7GOptNMVokaUyVpye5zO/sMjk1CTLniLE\nIopso5PGAmkjRIo4FkYLLyGIPBzbQaGI/RgtYzQhkhghYqLIx7EdhI7JWJYJ4ooTS1NpIYTESPvF\n2hpCx++PrzRIwfvJhGvFTirA7OuDyCfSxodcJo2nknKdqChFErkJtkzkbtqsgto7Ea31HZ747dVO\n+zVUyWvdLuyhid1CBz6KGCvlEIQgLAVaE0a+abqiEIWVTNvrU78QCTwvNSTnRgqj3beITZMW1HFl\nTGVlgWw2Q+gHSDSOJbGFT+A1ULGPrQS2mybSLlqn0FYAkSZnOziRNrwGS5sAnVYTyxZoHRAGHsQS\n103jplIEYYhUEt/zyGWyeI2GkcCFgbn2o5hYm3CcKE5S1aKQ0G/iBXWklLi2je+1kLFmbPtWmvUq\nN8ZvE8aCldVVHEvRWF3Gdh000PA8spksStk0600spbAsje+1qJVrxJFPd3cHUeAzOTXNwkKZyIe+\n7l6KnT20Wk2y6RSFjhw7xrZx8dJZOjrzLFUtdu8/TLGrj8DzOLRvP6dOnWJ2bg6XCNexmZlfZqFc\n5Z6j9/He5UuUpm/jSsH+AwexU2mEiFlemuf61as4bgoErK6W2b59JyvLy/T1dDM1PcWtm5Mcv/8e\ntu8co+V7NCpVapUVuru7OHv1GraT5uzZc/QPDJLP5ZlI9OMrlTKzpVl+9/d+mxs3r/LEE08xMDzK\n3gOHefW1t1mYW2Lnrh1sGRlgZXGWTMpmYX6WMPQ49c6bEFp8+rNf4PKtGwwNDRB4PtVKDddOs1yu\nkLFSNMsNAn+V5cUZRBSwZ/sYq3MrXB8f5+EPf5DS/CK/8//+AXt2b2N25jZh6CC0pK+vn9HhEZqN\nurHmjTWvvvJ9smmX5YV5wkAztusQxb5hNm3ZyuzKAi9//zniwCeXTZPNpKlXy2zbPMq+PWPcuDbN\n4uwEpdlZCp09jG7eznxpjma1Smchz87tgziZIoVcB+XlBSrlFfbs3skTjz/F7331q/z4pz6HZRew\nXJdf//e/yMrUe7i9Q/z8v/33rNR8pLLoGejjT//o/2ZwcBMDW4dohB61Zo3eniKtWoWOfAdOugOl\n4NatW+TSxgzp6H13//0v4LOr1bUH0Z4Q1u+b4y/zwRZam5tYn2AcxyaXy1IqTSMluK6DyfBeh6TN\nRBuhJGYU486b+ZpACtZUtW2pkoGDk5+XsH8lEqWhrS8X2sQ8KiHXHqMlBTKOkXGIin0Krk1GaWpL\n82QthYg8lI6wpMYWGtuCjOuQTbtk0y620FgxpJRCxTFRqwVBQOwHRLYw0XuJf7W0jPWrEq6xB1U2\nAosoFvieR7NSZkt/Ny+/8Axjm4dQIuaZP/9zitkMH/+HH2V1fo4DB/aipJnJLMtFWhGO8HA1YFm0\nIoEXkzDwY6SIEJGHLQ2hS0rLSKowTY/jWETYRNKi1gwZn1xgenaFSkMT6BRoZSZUYbzl2zC1+dlG\nz2xLhdIC3/eJI41yjbQtDOLkOSqkBlslwVaYpkoijQd3cgVIbabNOEqarLWccAMha22KmNSm+VJJ\nc2Zgc+NSpkRspFYadBAl06uBtYUAZSUs+jA05KuExGekZW043JRVAys7hrQmYvWVcZ0AACAASURB\nVPzAM34l0sgOQ20RRgbK1xaEaCJtijXeKo6bXtvbR6FPypYQh8jYaL7bUH0b3dIadKyQOkZJE7up\nEUbBhkTEAjsOKM8vknUigvosrpUk9cWe4TLImHwuRcv3QaWx0jZCBTQ9H8dN43shrm1RrS4iZEBa\nCJaWazSbVQodOTQSXwd4UQPbNWYhuYyLLTWuI9FxgNesk3IUodcgl7KpemXi2KeQdZGRh1dZgsgj\nn0pTXlykqzNLs1FB65BGs0Ghq4u0VJQmb1CZn6Qjl6Nch1wuRzHnsjo3hysM2kDcxLYjzp8/Qxh5\n2JamUVtmZaHEfffey8uvvMLUxC2OHR4i3z/CzFKFHXuPUPcFlUbA1I0bbBnZwtbd93Ht8vdZGr8K\nrTmiuILtpNi9ZztTt25gKZer713CUoJWo0YYBZRrNTp6BpiYL3HxynuUyyvsG9uFV2syMz3N2M6d\n9PcN49VbTN68TbNWRsrQhJ4sz5uGTGiajTp+FDO6bRfVukd5tcTxY/cyNLKZcrVJR0cR4eRwC72U\nKxXeefZ7zE+P8/nPfRbLzaKcLK+/eZKuzgKPP3iM777wEsXeATLpPNJK0b95C8JJ8d1nn+P4Iw8g\nVchiaYFdu7dwfWKcjs4RsvkinZ1dfPXrfwpKM9Q7jJvKI5RNd1eRdE8nW/fv5xvf/HM+8eQTzN68\nwo/+yKdpVELmbl9k+uolLpx5laa3wPziLDembnL5ymVyqSxPfuRJJqem2bVrN1u3bOXgwYMszM3i\nKovhjgLZjEUxm6HQYdGiyuLsBJfeu04tWuXwsaMI1+W1109z933HeOTJx7hw4xZ79mznyqm3yXUV\nuXrlHB/7+EfwYkkqnWFzb5E/ffolnvqxT9Pfkad0+UXeeONNRrfexY984RfIF4ZZLq8a7/iFRUYG\n+3j+hZcodnazZdsOYqmQSpBNKRqVJRqNZXKZDFHgUauskkulOfzfgg68VK59+a9ief91R3tvaO7f\nCXOn01lWV8tUqzUymRyumyIIDLPZMHITK0kkFiopvBKZ2IMKLTEKqPXPK2EZ1vEGyFW2DVbaE9XG\nI9boBG4OfR+ZTOxSQBQGyS5T0mg2yGazpLJppFAoux3eEhKGAUFggiL82LhqaQGOrbBtC2nbCNs2\n8GOsTbiHTFYQcYjBKWIQMZLQFEOh6cznWVlZ5sK5cxw/dpQ//spXkELwYz/+SW7cuM2+AwcNHJu4\nhQkdYUuJpSSxNGEXtiWIfY84DIi1JJ0r4mtFvRmxWm1RbUYIlcKPBHOLZRaWyswvrbK4XKVcaeCH\nECcuXG0jl43Trly7b17XdviJ5djEkSbwfWzLaICVMteCkmJNemgKZFtzTwKyrxMAzaHXmsaNv1sl\nedJrHtvizrNryIzrTWZ7tQECnTidRWEMycRvKTMRi+QyibUmSlZDG+Fz27JJpVyzHgoCE/cZxohY\noxQmolNZiaYb/GYZ202jpY2yLAK/hRICN5Uy5EplkB9LCSJtdsjG9z0hiibSMrVhbaA0xGGLRmMV\nS3roMCSKpLERthWWdE0MqFKEXoAUxiffshSB3yLjukhiQq+JVBovaNGRzeIFMSvlBVKuwvM9Mtkc\nUgpaXsM0FFIm1r8Rge+vpeuZ86pYqVTIZHKEYUDk+cSRTyblEEUhKytLpFImKyEIQ7xWi1azTtp1\nsG2barXG1NQ05VqDtGOTz2WIoph6o0o+l8VWklq5jNKa965cZvPQELVqBa/VolZvgu2QSqU5e+oN\nOvpG6O7rZ2z3Dq5fu8yWLcNM3DhPEDRYbdTx6xV2btnBzPQs6XyWRiOk0WiyUJpjenqC0dFhojgm\n39nBwcNHuD0xQU93FwLN3r376Cl2sbK8zPLyAvV6jWP3H+XShctcv36Nzs4OMuksJ157lUJnJ/Pz\nC4yN7eDatWtkMhk6C0X8VkCpVOLGzffYtmMXo5u3MTw6SndXNyvlCk9+5CmymTRvn3iWpz7yEbZt\n3cFb77xLOtfJ5q3bGBgYYGFxjvseeIhcLk3se4zfvE6jtswbr73M5K1rbOrv5tL5c+waO0A6k8Jr\n+nQV+1hdWuL2rQsI3aKrM8vwpj7Gb9/i3LunWFpa4MW/+Au2bhmlkE0zffMG+/fu5q3TZxHSwmuG\ntGK4fPkqaddlZbXC8WP3kU7nCIOQzkIHURhiOTZWLs0bp9+hd2SImcVFhCvJFfs5e30KT9tEVY9i\nsYeRLTvo695CvRoxfnOa++6/lzdffxW/2WTnjm28deJFZNhCOmkcBTu376BebfD4w4/yzT/7Bjdm\nS3z+i18krFf4Vz//JY49/Cj3Hn+Y0d2HmZqeIZW2kTLGkYoD+3czNLyZGzemqNabZDMFLAQqjrGU\npFxeJZ/LkHIsVhcXqFUrHH/o/r//BXyuUv9ye4r+mx7vh7c3vsm3yVJdXV0opVhYWMD3fQqFgoEg\nEyjeUiqBmH/waDcHa5B9ex8Zh2bCTkwxzOci4iiE0DDBgyAgDgLiKEToGCnAtiSuZaOkxLEtHMvo\na1Op1BrsX62bcIkwDPD9YK2YRFEISpBKpbFtA4nGGCa00MLocGNQyRuxJYwtqS0jLAlKxEgipNDJ\nxCXwmx5Dg4N89Q9+n0cffZQ/+spXyDouj3/4QyxXauzdf4CW52NLA0NbSpBWCl975nkJII4IPB/b\ncomFTansMTu/yvR8meXVFitVj6XVBkurTVarLWoNj6YXE0QSpLEnjYVhjlsbiuFaIU0+DgJ/7fNa\nJ85vUmFZFr7vrRVSKSW2ZZuCZdlEUQwJgz8WSWKpANV25AE2kgR/QHe/4XJsf3fbGW4jz6FNQjP3\nDW4Q6dh4gStlzqVmTZkQRZGZtkmiV2NDyGsXciEhDEyDZ1kqWacEpFyHWAck1u6mOYyaZHJ54gjC\nyLioeX6TlJsmimPCoMVael+YNHCWCcExkISRUYikYZIIbMtCyAjPK+M3q+TTOZN0JwXKdmjUW4SB\nh4giFhfmKHQUaXlNdByRy6TwWk0cpXBtC0REy2+AF+OHMXHskc24lEpzdBTyxJisc78ZEoUJSS2K\nWFhYADSB5xNFAdVahUwmi0TTajSwRUzkN2k2VrBdi76eHvzAwO1eyyPl2vi+T7PRYGhwCK0FS8sr\nFIt5Kqsr7N29h0tXLkKscW2bVq2KDgOqKyvUVldRyqIzl6enuws/0ozt2cfk9CQyajGzUmV4dDNS\ngFSSK5cvUpq4SdqxyHb24DfqdBZ6GRwaJowjOjq76ewsIqVgYnKcp558kqef/T6jW7bR3z+A12wi\ngUcff4wLZ8/zhZ/+Iv/p136N6ZkpEDG3bt3AcVL0dPdQqVQozc2RL+RxnRSR1kxPT2ErG6/ls337\nGHNzi9x77z1cuHSObdt2MT07h5tO093TRblSJp3JkM+mePfU63R1d3P54mW6uvvo7O6js9jF2XPv\noqTk0tVr+I061aVFyouzzM1OcO3KeQ7t282unTsgDkm7eZqNKvXyCqXx25w88RKVyixZW1CausnW\nLSO88fKL9HV3USwWqSxVuXnrJj09RWYnJ0FrXjrxMv/4J3+c7TsP43b0sXXrDlxlU6vXqC8vge3S\n2d3Fqy+/Qm+xm1u3bqNSWVoR7N93mPJSlYHRUVZWGzzwoSdQ2MhKwKaBUXq6ByGCXLaT3WN7kKJJ\nT3cHW0e30pkvsFCaoKcjz3vXbhD6Pgf3H+K1197gvqP38uu//r/xM1/6Eh96/GFe/f53+e7zL3Pv\nw4/xyGNPstoKTLaB18BJ1ritZgPbyjCyeYzLF68gohgdxtQbLarlMqOjQ0yN36a/t4vS7AxL8yU+\n+MSH/v4X8NKGAr5G4kn2dndOPXdC6xthdUOAW5feCKEJQx+lBB0deRqNGuXyKo5jJpwoCgy5Ryc6\n2A1QurG/TBi5ov02GxuSVrLfjaKIMAggjJJCarKllRRYUiYTqoXrWDiOjSWEKfLE6CggikxAShia\nTNxsNkcUhlTrNVKuSzabu+M5KiGJw5jQD8yk3S42cYwVC2QUI6MY1YZN4xhXaCxiA/miTTeoMYEj\nGkZGhnn+2WcoFjt48dmnCT2PBx99mEw+z8DwIJ7nY2OmWcsCv9nEcY1+PNQQRgKkDVaa5WqL89cn\nqbdCQi0RykUoBz8U+KFGWDYIG4SFEMb6MxaKONkDW8l6447s9OR6UEre0UQZZdZ6wQ3DcK2gIoxn\nfBiZjLc4Tkxn2kVbCNO0yXaz0L6u9J3XlTZXn0r+z8bCvq7wW8+rXz9XABrHttcUERKw7SSCM5nq\nbdvGdhxMH5YUUSHQUYTQpjlzlFxbA4RBgONIYmLiSCMth0a9gY6axFHiIU+Mpcw1gRSEQQhhgEye\nhyHOaRTtzHKzqoiSv4EoNtenpQRB0EAQ4Dea0PLQwiOKQ/K5Ip7fQhBjK7PyKOTzhMnqQCib1XKF\nzq4u4ijEciTNVh1HWCjlEPoN4sjHtVyUsmnUq4hYE/gRTmK6oqSk1WzSaNQSYqRBO2wlaFSrRIGH\npWJ03CTwa/ie4R+srpRpNJvYlpl2eru7abZa9PT2kUnliOOQpcVpmo06cawZGt7E5MQ4jVoZR0ha\n9SrFYgeuZVOamqQjnyOTzeOk05RrDXSs6SqkyfV0c+nKZTo68/T39lKamaK2ukh/Tx9H73uQWCuy\n2Tzlao2u7k4KHR34fkCzUSedSXHj+g38KGJ2tkQUaUqzM+RSaToKBd45eYp6vcEPfeQplpYXuHz5\nAsPDgxy7936q1QrLyyts376dbTu2MTQ8xM2bt+jt66dvUz9Xr15j9+69bN++C5DcnrnFwMAW3JRL\nuVzGcR0a9TpB4PHic8+Sz6Tp6+kjCkJ6ensRUpLL5xkb28Xg4BDLi8sslmbQzTrTN69x4cJptm8b\n4cHj9zE5MUEhX8RWDinH4uK5d1kuTbB5UxeVRpV9O7Zz6MABGl6LkU1DKASdxSKbh7Zw5PAB3j19\nmrvuvofbk7N4OsbzQvbsO8qthUUOHDjM3NQUjVaNvs4C9UAzMTnFkUMHyLoppqZm2X/gMLlMBt2s\nc/fOrZw9c5YDu8ZYmJmip5Al60pGRoaoVVYRdsDM1C0mJ25QKk1y+uQpvve9Z3n2+99nYvwGt26N\nk3Zs+nr7WV5eZmpqilQqxTunTyOV5vzpt1lemGPZC/kXv/BvqTUjanWfjnyeer1M2nHRgO2kmZ6d\nZ252iUN797A0N8v2rduYW1wiV+ikVl6hUV2lVa+hQ5+OXJajx/92E/jfCSOX0+Oz+g6mt2ZDIf/B\nCXld7iPZqJNZZ+waaLrts93O9W6HLiwvL9NoNNjUP0AcxPi+nzhhJZKaxLd74639e1Xsr01bJtYz\n2kDWWmcMt/+fa1koy4x/JqY0QMfGoMPIzQwxTAhD0CF5g6/VatTrdSzLodCZN3kfsTZWsXrdPMbX\nAQTmTQ61DoOaoIr159N+HXRCi1aRxnIUfq3CFz7/Wa6fOUUhk2Xs4H7+3a/9z/QPjtJoebjKATRO\nxiFoeaTcDPVQMD5fZnahStOLELFGKowJSKxRyjB9W03fwMK2jbIEIpKsOdJLI1vScbuw3Gng025O\nzGsbrUHZcRwT015hCMIwMPeU8ZH3fR8nlbmjsIpYG1/upDFUOiYy+aXm94g7SWxxHJtVRLyxmcQY\npSTXxl/mnNc+p20Tlvb3KSHW4jzb1+kaC12YGNggyURXSUOihERIg3BYrjFOiYMQbUlQDl6oSDk2\nfnkeAWTcFMqxUUqwtLRkiI5CIsIWEZp8Pk/T95FWCjudQSNo+MGa5E0oI+0KPJ8w8HAjj2Kxm9rS\nEimWuHnrPXIdPQinQL5nkNWlZXQcknFTZAodrNYa+IEm11mk6fv09/SzWJohlYJMzmV5chbXySFE\nC6k9pqdN8le+kMXzPGJhzler1aJSNkqSfD5vziMRxa4uZidu0tPVlaxsAhYWZ2n5DVwnRybdgdeI\n6OrtxAs9vFaAa7nUWy0QgmajQUc2TWnyBtPTsyAkHR0FLKXo7+8laHlksinmFxdZWVmht6ObS5ff\nY/fBQ3T0DIDlkstl+A+/8mW++KUv44eakaFB3n77Tc6fP8vu7QMMdHUwMbdMqqOXXTt3sHV0M3/x\nrT8mlXIYHNlNvVXHVg7f/+434P/j7r2CJMnv/L5P+ixf3dXVvqdnusfu7MzOulmswywW5nDA4XBB\nMWRIUUGdQqKkUEgPiqCCkh42Qg8K6U16kDkyeJREho5nBN4RZneBAxZYg/UGO7Z7pr0vb9Jn/lMP\n/6zuWYiiHvRCXE30tKnuyqzMqvz9f7+vSwSaaqCqKtPTs1y6cBHXd3jzzTd58cvPo6oKnj9ge3uT\nYqXM2uoG/Z7D8y9+JXOmkwTXra1N3nr7PW7ceIF+v8/29i5hIJiYmCBKhvzbf+vf43B/F8PK0Wi1\nSZOYsUqJ1177Mf/pf/Zf8M4v3sAyUs4/ch4nCOn2A+bmz2JpBRIlIqcLtMjnz/74H7OwfBqzkGN3\nZ4/65ARhbPLMjW+RL1excxprqzcZdNpovk85X0aoOrESU7B1vnbjBt/73veoVse5dnmB1bufU52Y\nY3HpElv3bvKHf/8fcESR/+Tv/j3ee+stLEWa/ExWStzc3Oc73/waqyt3ufmrT/nGb3+Hf/pnf87v\n/d7vMZ43eO/Nv+Q73/pt3vnofRobO9xa2+RIUbi4fInpiRqVQo5mYx/H8fjyi9/G9UNUI2V2/jRK\nEvDWW2/h79/ms1s3afeGvPSVL/Oj137M5uYmE+NVTM3GCQR/8E+/jx+pNBod5upjrN6/TbFcYWJ6\nliiNcZyAfM6gaJvsbawxOzlJu9On6/osnlniYHudnBoSeQ7zMzW6nSb/1u//nX85k/r/4/avRAe+\n3+u/oijqSeeTFW3toYvnF2+jjifz/FZPLqAy3EB25LJTjvE8T2JjUUgQ+OTzOQxD4+jwCMs2KZeL\njPzXdUNDNVQ0Q5PzUjVFkJCk2YcfSDw6joijGJFFkirHFpXKcYclpTxJxiqPUXXp1KYoMsEpiiJU\nzUDVNCIhRwhJKvCDEHQd07az1CuBYdikiiolWFlKWRRn3u9ZljWqxHlF1oEr6ihzXOFk7iqR4DRJ\n8TyX0wvzjJVLvPPzNzg6aPHVb36Vf+Nv/A26/SGKomNoJpqh4yQxppmn7aSsbO6zedjBizUsM0+S\npCRCyTLCJbGLDI82DR1SgecMMdSR/3c23UCakahKSpI+1OU+PMYmCxRJ5dQjzdzasmeDlvmoS8MS\nTfrNi5QoiuSxyaYjqSJfLyOnP9n0Zos/hS8svk468Ow2WlSoKqqiohnGSTLX6NWoKF/4EGl6fN+I\nPJaITJutahk1Mh1x2Y67eiUjlamadEFLREIcDCCRr6F8zkbVTTwnkPK3yGN3a5u5mdmMgS7QdY00\niVBIsgQ4sO08fhih6LpMKUukrEuVJgvHCzwSgYgSfKeH57kUyxZK5BP6CbqR46h1hGGaxFGIbVh4\nvkN5vIZAA8VE1WRaWM6y6DVbaCpEQkIgQ9cj8Pv0+205UbBtoiSk3WljGAa+71MslPE8D9O0mZyc\nQtN0HMej1+/hD7r4wyFqKi/uURQhRMrm5hbT9SlcN8Bx+8RRkNnNGrS7Xc4uL9NuN4gCH3c4ZHJy\nkpWVFQxdpd/v4bpDVF0l8F1SkUgpkqHhhyG5QolOp08YJaiayt7uNmfOnMfUDbx+D01TaXfa6GnE\nRKXKxNQcZ88vsb+7jtfvowgP3x2iGlUSTcP3HO7d/hW9VpszZxbRDZ3FU4scHTZQVIU3fvYzTi+e\nIkkDbt++zfVnn+HMmTOYVoHd/X1u37lHkirMz01zf+0+ruOSK9jcu3eXa49fw8rZlIolHqyukjN1\nTp87T5qEWDkb2y7RarXYWFnhytXHuPfgAWHgc+78eXZ2DzByeXKFEqcWTmMaBq1uk9mZCZoHm/zk\nL19jfHKSnYMGC4vLCF3Hztc4tXyRQnEcxxkwVsqxfOoUIk3p+BELSxfQdJONnW3urNzh3Nkz3Lq/\nxurdT1lduYVZqHJ/64CNu7d49vqX+Cf/158xMzlJfaLC+HiRwWBIdbzKzv4+h4cHJInAtgqcWlzk\n7bffJIpDitU6tanT/A9//x+Rq9YwiyXOX36Mr3z1uzx29TpPP/Ucu4cHlMp1Ll2+hpWvEANCM9lv\nNnGdIYpu8farf4Kma4zVJrl06SJ/9r3vUy7l6HQc+k7C3/0v/xs+u3UPU7eYmpik0dzDzsn38cHR\nEW7gMjkxSej2qOQNQnfAcNBG0xXcYY80jYiGfTbWVum1j4hjj1bzkOdvfO03f4S+3xu8cmyKghxx\nqhmuOQrqeJhBPvosmzSph47jiCj2SURMmgqi2CVJAlASNB00LSUllmPINMKwFPJ5i36/w9DpkyuY\n2HmTKJGPIdKYMPKJ4oA4CREiIiVBQ15c1ewiq2lZp69KTB2+SMQzDB3dNCBJCKNAWkE+FMUIqvTQ\nJpPHqLJAKFm3rOtyJBnFEXYuh26YxEkiSVW6hiFU0jiRtpaZmF5HQVd0+fMUWTRFIrH7JEZLE4Sq\nk7MtQtehcXTAG6+9ShR6TM/P8e3v/B6uH2KYNoqiESUxQaqwtr7F6k6b1sBFt0ooSHyWWKBoEvs1\nVF3KyoR00UtFQipSbNskjmSutCx8yUkRFwrJQ9LB486ZrJgrSsYil8EaSZKQpPLrMAxkpriqEWdE\nMC2TqcVJfKytT5XM1jSViWojLfRoQw+fszCO5KhdlZGYXyBYpilhkh7HzI4Mhh5eVP16vG0sRni4\nLvHtVHrMa5p2rKU3TI1UZNOSNCvuiYRuCrbkIcR+mMWjqmiahUgSKjkTJUVmlScxqq5hmgad5hGF\nfA5DzYGqE4QCVTVBz5EqOl6QoCvSPS7NXOUUFHRFTlE8Z0CjfYSqBygipj4+RxgLSmMFdne2MA2N\nfM7GcYd4UUCxVCVFpdXYp1odp3lwSMG2yBdyUv+PDKbw/QEH+zvMzc/J95GmEYQhtmGiqhK3npyc\nZm1tA9vOEUUxzWaL+mQdr99jbnqSwaDPoD/KD1fJ53K0Wx1ydg7bNmi2G+i6ieN4jFdquL6D6w3I\n2xZFy8bK2Wi6wt179xBpyuVHH8FxBgwdB6c/QElT2t02Y7UazVYXL4jk4ocUkYQkok++AB999Dat\n1gEXL5+jlNe4e+tzzl66yK3PP2N6coK9rW0MVTA7P8/sqUusbG5zanaKcNgjTUNQwDIsLj1ymVu3\nb1IpVVlYmKfROERR5Xum2eqgKCqrqw84f+ESYZzQ6/X56Rs/QVUU6hM1zp1d5u7dOzxy+SJ+EHL1\nylWODg9IIh89l6NUyLO5vomdL/HMU0/x9i9+ztVrj2MV5PE9f+ESVr6Amcuzcv8BUzOTrN67S9fr\no+uC9dXb0tymVOapZ57jxRdfYhgnlKp1Ou0usReQV0LqJYWt2zcpz87hixQvUVl78IBABESRx/bG\nOorwSdwj9na3iLQSpZllJueWUAsT9Bp7bD1YY25+kp29bWbqs6yurTFWH6damyBfqMpc84rF+upH\n1CdyzMzV+Sd/8qc8/83fZfHMeU6du8DCwjK7K5t0+k1++cvXEZpKFGqMjU2DHtPuDyiNTaEYFns7\na9jFIsW4xeVHrzA1PU8+X+AnP/0ZqpoSRPB3/qP/nK/81nepT0zy4P59fvXpx9RnxiiWbVJFo1Cp\noOkqxVweRfj0W02ODvbottuMVYuUijYiCjjY2WFqcox6fRxLh3srt/nt7/z13/wCftRtvKKmAkOT\nxK5IieSIU5Xd1MO6YlBlxxcrUsKkyAuaJDBZmKaNYdoYRg7dsFEVA0010XUb07AgVUmFItneag47\nVyJJFJrNDnGUYBgWcRxDqmJoeXTdxLbymFaeNFXRcnmZW2xYyGxDnSRVSTMUV9Gks5ii6iQCOt0B\nfhCj6ia6mUczcyRCI1UyrbNukKgWYQyxYuG4gp39Fs32kEZ3yPrWPppmcdTssrN3RKc3pOf6HLa6\nDJyASKiYloJumoCGotnEIsULAhTDRNENFN1CMUzpfW0YCEVBaDp6quIl8OjVa/zP//1/yzCC5268\nyI3f+hYr9/fouSk7Bw2295vs7ffpuD4JMio1iWKJD6dS424YxvHIWwiBSEVmtqOjqNIpSjc1mWaW\nynOnZph4mMW1jgiII3hg1OUmqbxfU7Ix9HFSWyqTw4CHOeLpCIJBjqmTVBzjvbJgyklJksSoiio1\nyKqUZQkhMFWdKI6kbzryQ9U0iSunklkud1gcE8AURabXyQAXkRkRAYrUWCvaKEJWRVW1bHsCVVHR\nMxnXKKrT0DR0Q0e3DSI/QkkFBV1BpBG6lUekBlEqR8uGSDnY2yJnm2BYCFVBFRG6Cv1+n7xlULYN\nep0jgiiiVBrHDxN0S/q9x56PbVsMPBc7l0NNIaeZpFqCZWoMey0sU5rW9Ic98rkCedvi7u17VMpV\nDENBUROGQ49KdYxe+4B285CpqQkC3yUMAmzdoNNv4g4G1OuTtFttTDvHwqlFhkOPfC5Ht98ll8+R\ny5dQdYMgihgMhli2Ta/f59zyaQ73drBMA8s06Ha75PIyVzxOBflCiVanxf7hLsVikThKUBSdvGkR\nRT5J5EEakkYxqgKu52FbBoN+n/29PaYnp2g3m1QrVcbHx/FcFxQVx/WYnpklFYKJ8XFiEfHxR59S\nq9RZmDvFvZW71KsVarU6vaHLg3v30XWdifEi/rDP5uYmpp3HylVZPL1IZ/8IVevT7Q54572PKJZL\n3H+wxqOPPEZ9dpyjowMajX1QBLadpzYxSRQKDLuEXSyTiJhHlpa5cGGZO5/f5GBjh3trq6iaxvVn\nn6HdPKLfbnD98ceIvIBipcyDBw/QTJ2xapU/+IM/xA0THr36GJ1Wg8O9fSzdJAwCGodNSoUc/W6T\nc+cW2dneoX24g+O0OX/+AvlcjZnZM1i2xdZ6g2vXnsSNAzY3V1iYm6I+NfofuQAAIABJREFUVqPf\n69EahJTHpjHzZeamxtAVOLu4SM7UcJwBCxM1pmozXLzyNMXqOJPzp8npMFbS2NpeZdDzOX/+UR5s\nrSAUhWe+9DyVXJmF+dO4fsCPf/oq1595nMGgx9LyBQr5MvXpBdb3GihpjjgISayY5uEeVr7E4uIZ\nrNIEa5t7OE4fVdNBVVFtBUOonJ6fZfPeR5hWjkqpwvf/4nu0OkfMTE5TKJX4/f/4P+T26l00ReHi\nuWWS2Oe1H/0zxss1ioU8tpZKGXGSki9Y7G88oFarcnh0QBKFBI7DmYV5ROgT+R7bWxs89/yzpCQ8\n9cyXf/MLuBf6r0R+hBf4xKnAjQJURSOJR12qIot2khG6VANdN4miGBmikOK6Ad3egEHfJ/ATOj2H\nVqPL4VGDdqdH6McIIbvaJIEkUdg/aNHrDUlTlYlaHd8PcVyPSqWGruVIhEK/7zIYOIRhgufF9Lsu\nrWaXZqODSGQWt6IaKKqBHyU4fkRv4NHpObS7Q46aXdq9IY7rM/RC/DBG5nQY+EnKQavD3lGbo2aP\nw2aHw1aHTs/B8wVxopKmOt1+QKpYxEKn3XVptx2EMPADaDaH9AcDFNVEYNPrBbTaDgeNFj3Hw48E\njh/T7g1JhEKq6oQRCNQsEjElDgP+8H/5n/DjlEp9inOPPs7G9hGOnzIM4myxZKGoZmZKIrtlTdNR\nUE/wa0466BNCIsexoUKkGUtbFuuTKcQXSWkjzsEI944TqbMemZ2ILKhDfZjYlrG+QRbwJMOUYYRR\nj7Zz4namqiqmaWUueFL6pahKlrQmLUUf9tYfLTA03TjJQyebDaUnZjsPE+7gJIXtYXtf+TpWMr+B\njLCnKMdMcJGmpIqKrmiI2ENNBH4QYOULoBjEqVzYmoDT66IZOqaVJ4illWbge4RhSMm2MLSUIHDw\nPKnRTlUFlBgFldj1pQGMoqDpcmpjajpxFFPI5VDTlNAPCf0ITTVYX9ukUikzOzPHyso9JiaqRHGA\nbtukqUbe1IjCENvQGfS7GKqCoUPONOl1OgSug6lpHB0ccurUKfr9Abpu0Gk3yeWLFAqy+A76faan\npxFC0GgckbM09rY3MFSFYj5Pr9vD0HWCKEBPwR04PHLhPJvrD2g3GhTtPKVcCc91gATX6dNpNalP\n1PA8F1LB8tISYRRx7949XN+RDPg4ZnxsDA2wbAuRwtb2LqZuMzU5BWqCbZrYlsHHn3xMfWKcJImJ\nIp8L584TRiFnlpbpdpu0Gk3iOOb0mdNsbOwzXhtj2GuhpAGDfp9er4vrDHjs6mMUc0WZ+aAKhIgw\nLYvp6TlEqhBFMU8++TSGZRF4Hvdu3mbY77F0+jQ3nn8REYZUyxWK+QK5XIF8oUhtYoJPbn3O3t4B\nFy9d4IXnXiAKYz795BOuP32dxYUZhv0+y4sLpCLi8OiAdq9LvV4n9EOiMKLVavPzN37CmTOnKRbH\nKJXraJpFt9tle2eP8VoN0zTIWzoT1ZKUVRXLPPrYs1JLnS9ysLOOmgp0FVbu3GJh4RQWETc/v8W1\np19g97BLHKYYScLMVIVUjXn77Xe4+MgjvPy13+KtN9+jVqvh+j1cd4DvDnnpyy/y7i/fZWVlnYuP\nPMnzL36Nvd02j158BM1zcft99g+bVKuTXHvyeVa3t5icmiEKfdbX7nH9iadQYrBNE3c4gDShpDmS\nVOkG/OiHr5Ivl7BzNgtnlklVna2dvczYKmT5zGleeuFZ/vd/+L9x+tQCV69cYdDtY+gGSeQzVi2R\nxIKxsSqrKytM1mvkbBtV1/E9n/29fYRIyeWKPPbk9d/8Av7WW++8Mje3IDNifYdCZYwkgTgC1wnp\n9x16gwGDoUu/69Dt9un3hvQGQ7q9Pp1uj/7AxXEjHDei23fxvYgoBpHqRHFKf+jR7w0YDDxcL6TV\n6hEECUEg8P2YRqONoqp4XsjGxg6Hh218L6HTGdDtDej3PDod+dlzI8IgoT/06HSHtNp9Dlsd2j2H\nds+h7wS4QYIfpahGDkW38bIFQLc3oNHqctTqctTu0R6GDNwIPxYEiUKq2GhmgVS1CBNFRmPaBcIE\nwgRK1RqqauL6EYlQMXNFkiSh3XVptga0+y5DL0JRTLw4wfESHC/C8WJa3QGdrkNv6NHrO7S7Lr1u\nD893+OM/+sdoukG+PMELL38bJ1JJ1ByoJqg6IpGe46o+InDJwh1HyTELXDalQsqiMvOQEQ4s0pQ4\nSbL7RoCIzHAPMs2vpmnHut+HCV8jNrqSYfsj9necJWmNOu4RkCzECTt8pK+W/AQZKJIk0i0sSWXh\njqJkpKY6kXIpisShHyIoAtlkIOvus457tD+JOAm6GREolWxKcfxcOPnaGGmvkfh8kmTbyP6P0wRN\nVTFUgako+KGPlS/gh5G0FE0ThOuSJtIpTzVtoiTFMg1EErK/t8fcxBi2qTHod+j2BtQmp4lFgqKl\npGFMEkXIiBPI5/IwssglJgx9DF0lcIbk8zau6xBGHqsr64yNjVMo5PG9AaqeUqmMSajFcVCFIPBd\nJsbGSERAv9dlYmyMsbFx2s0mY5UyW5ubGIZ1PA3L2Xn6PanzLhaL3Fu5Q6VSRlVTCnmbo8MDTEWw\nt73F5EQNTVXZP9hHQcFxHCxL6sGnpibY3t4ilytg2ZaMwyzYNBr7pCKmUiyiAJ12G9dxmJioUSjJ\nLIVOr0u9NsH+3h62ZSHSlM2NbU4vnubzz29RLBfJF3M0GvtsbW2x/uA+i6cWiEKfRrNBPpejMlbl\n9dd+wuKpeVQUnOGAq1eucnBwhEhittZWuLB8GmcwxHEGfOUrNzBUk/rEFJqqUK+Pc+fOZ0xPz7K0\ndIF7K6ucWVrCcxPanTbucMBLL36ZD99/j0cuXOT6k0+i6CrV2jh/+r0/5+WXv8ovfvEm/W6fSqVE\nsVTiicefQCQJP/zh95manObpJx7nweoKi3NzeL6DbmiM18cxLbmY9R2P6fE6r7/+z7FMi6uPP8HS\n8kXanSFnTp/l/fekvWuv1ydn6RR0hcP9Xarj4wz9hFJlmt7QI0lTKrZKHIeUCzkSzyVJU5zGIZZu\n89mdNXSrgGVaNPe3eePnP+SRSxdpNBv84NXXePLx61y9+hQ//NGP2N7fpz41zVNPPs7P3/gZqoC/\n9Tf/Nt///o+YmZqmUK6xubPJ6YUFfvnhBxjVEteeepr9owM0xSLwHNIkYGysQN7OMzZRR6Qp/XYH\nU9VY/eRN7q2uYpo53n33fQrlMr1elxs3XkIzLWIhePXVH3Hh3BJOv807b/xEcisaTd568w0WTy2y\nv7NDErmUK2VcxyEMXFQEjaMDIGWyPsndlVucu3AOP/QolkpcufZXwIntrfc+fOXDjz5BNwzm5xc5\nbLRpNroM+w6uGzMcekSJHJVHEnIlShSiOCWKJYEKRUPVTFRVB1XD0E0UVUPVdHTdxLJyGIYJisRK\nNd0CdBRVJ06EJGq5HigqhmkRxYJuz8nwMlNKdzQdRbckqUrXpa1jyrG9o6pqSNtQlVRoxHGKSCCK\nBLJWqOiKntliqghFB81G0UxQdEQqi4PEVWXwhjZK+FJSNF0jjkJM28SwDKIkwvV88raZBVmoKJom\nO0olJVZ1UkUlETKnOUVDpCqxUPGCmCBW8D0HU1f5i+/9EQYpulXlSze+jusreHFKlAqSjNSVKClJ\nEhOGkdQdR8lxsfv1rhNV4rgnueAiszCV3AHZmo++l1h6HMcEQSD/POvC4zgGZPc78hcHJFHshCb2\nhUIJX9RmZ7+eRb5CHEcSZ84+5HOQ50T+/sg8JjsPnEjGJHNcO+6qj/HxEVP9oUJ/rKx4GNdXHiZc\nyvukjEwen+wPMvMZga6qWLpABCFxmlIolSRL27TJ2RaJ7+EMepTKBaJUJVVU0kTq/+MoYqxcQNNV\ndvZ3mV04jV2s4oQhqqESeQFpnMjc6SQmJcUZOni+j23q6JrCoNejVi0RxxH5go2qK3RaPcIwZGK8\nQqVcQje1DEbSGHZ6jI+PUyjkEKmc8ERRDIrBxMQkxWKR1dUHJEJw6tRpEiHT6HTDpFgqAymu6xIE\nPhMT47RbDVJkB5fTNSrFAt1OC4WUcrVCkghK5QLdTpcg9Njc3MA0TVzPpV6f5N7du4yPV+n3ujj9\nHuViURpqVEq0Do8IohAFhUKpyOzsLLtb25TLJaxsjJ/L5ajVJnA9V4YS5QwKeZu7d+8yVi5zdnmZ\nOIyIk4RWq42m67TbbRQEtmkSRRGpELSaR1iaShgM8IcOrufSbB4yv7BA7Ec0Dhu0Wy2WlhZY37rP\n6dPnuHP7Pv3BED8IOThq02g06HW6KFp6zD+4e+8evWFXas7jSF47opj5+Xksy2RtfY1yucTh4REP\nVla5euUyqqIQ+C6mZdNotpg5tYBm2PhhRD6X42Brk27riObhLhfOn8f3I04vn8O2c9xbvcfag/vc\neOkF1tcesDBTp2xBt9WgWpvCLFZoNFpEcYSup2zev0OtWmXl9m3qY1XiKCbsdbBtm6nZRXKlEoZt\n8NYbr3F6YYY4EVy5eo1mo83Nm3eYmZ1nYmaGRy8/ijcc8PZbbzI7M8fTT32JZlvawSqawLDLTM9N\nsbe1SaPT4Utf+SoHeweMVyr4fZ9iTlAp2UxNTuL6PnfvrvD66z9lZ2OTd3/5SyqGh5W3qNeneOeX\n72Ln89i2xe9+9/dIEsH0zCxCqLz3zts898wzjGaRlmni+w4pKa4zZHp6gjAMKBVz0mQoDoh8n82N\nDSbrNXzfwTKlH4jnujz97F8BL/TK/NIrtYkp3v/gI95/7wNqtVkM1cRxfWKhgSLjDuNYkKYqoAE6\nuib1xJpmoOr6cYelGQ9fYOU2hIizjlASwKIoOU6PSrNxpKZJ0xRVA001SIFur02cxOQLUnoTqxCn\nCUnml/0wC1lNIYnl4wopPpYxnNkeS8926a6VAmRSr3Q0sh1xk0WCQoqhplKnnibHmvQwknpcjTTT\nmmv0220s08IwDaIwAFLiMCKME0nYSiUre1SEoigmSVUSZBhMPmfx4x/8EVocIRSTl7/+uySpSpSk\nMspRkcRAQUgUSB3yaJw9kkGlI7w4w3+PmeLKSQcuMv35iPiVygoucWFOUrnk4ZSa5WN1QsYCzw6b\nvKlysTS6KcfnXM0McE7MVk54FIkc/afIUbiaGaRmx0Y+huzGQRLe7JyNbdtompZlvT+Mt2dSs+N9\nyJ73Q527crwPXzQGkud7pHmXD6upqjRuybB1U1URsYeSpiQiRjdtNEUjEjGJiAl9H0tTsWwToWqE\nQhBH0m60cbCPnc+hahrt3gCzWCFKddnF+z5aHOM5Q/K5HILk2BM+CkM8x0MkUCoUpS+5qmLoJuXy\nGPmcTavVxLZMVAV+dfMO584+gmnmcQZ9acySJFSq47S6PVLNxPFjWt0+qmrQbDZxHIfJqSlQNBRF\nsuRVVcPzXDzPJZe3GatUMuMiBUtV6HUaFPM2/X4Xw9CJwpgwCqiVK6RxzOHeLrZhkjMthr0BcRhR\nyOfY2FxjdrpOPpejPlaT+QJKimVKxzvX90iy+Fx36FCtVnGGDv3hAMMwWV/fZHZmmn6/T22qRqVc\nplwoMegNmJio0e10qFaqVKpVtrd3mJqsc+f2LU4tLBy/RupjY2xtrFGt5NFUg88+/ZhKtcyTTzzF\nYDCg3Wzzta++zNDpIog5e/YRfvLjn3Lp8qMkiuDa49cxDZ3Ad2i1W3iBx6VLl7DLeabLVTzfZX1t\ng6PGIb7vYVgmC2eXeP/dd9je3uHTjz5lYeEUV65cQdUUut0BE/PzNLt9Oj2H/YMWa2ubLJ05Td7U\n+OmPf8h/8O/+O2xt76AZFoVyCUHKx598zMsvv4xpGvT7XZJgyGxtjHv3ViiVKmxvbTMYdOh2W4S+\nQxo6JHHCg9VVZicncIYeU+UcnXaTSNUZq0/wD/7R/8pzz13jzOwC6xt7+L7gyrVr3L59k2bnkCev\nf5lyzuRP//iPuHT+LFP1Gd7/6FfMzC/SHvb45UfvkoiUatHmk7d+zDe/9hKra/cZr4zjDvu020cU\njJjd7XXee+99VlbWqY9P8PWXv86NL7/EhXPneffnf8Hh0QEXL17i5Zdv8P5HH+F7IY9cvISq6jx4\nsMWNl7+OP3DZWlnjkSvL9PoDTp06hZW3KFXLmRZcZdDr0Tjcx7YMVu7eolQs8Pi1x/jwww+olsc5\nOmgwVp3g8KDBja/9FWChv3t745Ve32F2dgHbKvL2W+8TRgn1iQlpcJImqJqGbmVELFVD0y00NXOU\nyiQ/o1jOVCRfYKinxBnvKCtEIoFMbhYn8j4hYhlzqChZprKKbtoYlkHguwwdh0TEWLkCqpqNVoWU\n7GiASOLMjnL0rE5iNUVWkMlISkq236qiHUdOjoo2aSrtMhVQFCFxBNTMlxxM3TjRJ2fkL0M1CIIQ\n3wvQdENOGlJJuBqZzuj6CfasoKGoKomISVJBPlfgL7/3fyDigCCIeekbv4NuWgRCgDaS5smAFk01\nj7vmhxcv0hIUsjNBMjIoyWRKUtaXfqGTPTFmkb7iI/KamiV0BUEgNfrGSTwrivTyFpB5mcvFz2hs\nPirGowVFVoflgoqRP4Au5VrayG0dEiHH+wrS1U8WWzX7Wm4rimKSOEFTkKz40XM4Hgr8CyYRcByc\nIh4ascvdOlmYjBCAEZ6uKAqqLiCO0bUEp99DNTRpkYqCF/jyfaBoNI928QKPQnkM1TTpd9qU8gah\nN6RUHiMW4MYxZq5EoTQuQ0NCFxH4iCTBylmEoU8Q+lTKZYqlAnHo0WkfSWc3p81w2EZTIQ4jNBVM\nQ+fBgwc886VnWd/YZWn5PLfvrDI+PoZp2XR7AxRdJ05SvCBkfmER0zDZ2togERGuO2RycobpuVlc\n30dTRoY9IJIAx+ljahqVknRf21xb59zyIo7TY2t7k739PU6fOY2mG9y5fYfZ2Vk83+XcxUu0Ol2a\n7Q5BFGGbFsVCnr39HcaqVXa3tikUc/hBQBzFkgFv53AdB3foYRoW3W6HublT9Ps9CkWpRdcNk2bj\niMeeeIz9nX0qlQrDwZAg8CkUCiRxzMz0DLOzc6yv36fRaDIYDqiMVQmDiKnpGpvrDxBpTLFQotGR\n7mjzc4v0enLcXa2W2T3c47DRJAwTDN3gsNHk6We+hO94mFrK559/jGpqjJXHmV2Y47DZZGFhge6w\nz4VLFyjkcnz4wfvoukGMwoWz5zg4OKI3cHjy6Sep16dptLu4UcLG7gHXnrxOuVrDtovomkav0+bz\nzz4mjgOuP/EkbhBRKFdotNvcvnuTBw/uM7+wyNHhIRsbGyzMTNBoNEgF0rbazrF09pSUD/oOzz3z\nHNs7e3Q7Xc4tL+N5Pmk05MNPPuDyE09i5C2KYyWmJseZrs+RL45Tm5ymWi0zXqvywx/+OU89+yJ3\n7q/xO7/7HR5//Enurq6yeu8+m5sPuLC8yKB5wNMvvMzq5g6Xz1/E8wOGkcB1PHbX1yEJae1v0W61\nmD21zPLFy5y9cI6Dw31W796hNj6GGjSp1SZYW1vjzp07NJptegOPhbkFvvmNb4Fu0Op5PPf007z/\n1tvMLU5zb3UNyzZx/D5Xr1xhfLyOYWjUKgWOjg5pt9vEYUQUh+zv7ZMkkSRMTk9z69bnPHblKlef\neuo3v4B/utp4JVZUAhRELsfyhQsszE6TRh53bn3MrZuf4Xo96vVx8nlpH5jEgjSNpOsUKSgCLZVd\n7giXPCERZclTqfSploESAg0VTZEBGSPPcyEEKAZJBImQjHVFNTFNyWrXghin08MfOpQKJTTUrFCB\n0BWEKt3HE2nNRphEJEpKhECoCkGaEpISCkgy2VeSRaKO8FpN0bN9VdAUCzQpPRJpSpBEoKmSWU1K\noiTSp93QMfM5wjhk4AxxPR8tZ6GbBooKYRxL9jkqiQp67GEYMYFiEiQGd9/6Ia3BgCBJefT6dcbq\nU7hBJItPqpHEBgoWiZBYdpyI4w56NPZPUbLFifZQwQYYddMPjZwfIpIBJKpAMbTs+Mnna9gWmmkg\nOWaya3c9Hz+Ksm2S5YqPYAe5b5JB/lCBhWycTybVklCAQCakqVlKmKIo6JnGO4yCDMLQjvFx2e0r\naKRZLOjJduU4Xi4aH+60j28pUpee7UuKfB3GiSCMYhTNJMmOk6GpiDTEUBNE5KKqMsUujEJM2yLy\nfTRdoz8coFsWaZx5G+QLpIpGztIo53RW79ykUiyCorG+tc3ymfNEYYIIPFJ/SBRHQEKxYOO6AxRg\n4PQRaULBEIjQRfhDbNVnrFRAEQndZosw9KhUK2iWxe3b9zg8auG4Ds89+wxenOJ4PqVyhbyVY+3B\nKjlDZdA5Io09JsaL3Ln5KefOn+Oo1eL02fOY+QKp1yHyHExdcLi7SdEy8YcDvF6PYDhkvDyGbio0\n2g0evXqFi488wnvvfcDa2jrlUomjoyPOLJ+l0+0zM7+AFwSgaRzs7ZMr2HQ7LXI5G3cw5MH6BrOz\nM5iWTbvdYbxaw7YLBH5AtTrG4VGTB+sbzM2f4qhxyNhYDd/1mahP8PrPXidwPc6fP4fjO/QHPRIR\nUcjLnO1+q81kfYxqZZz5U3N0hwNcP2Zz/R4TtQlavR6DYYd8MY+dL6MbJRYXTrF/sM7u/gZ37t1n\n6AuSKOTs8hKFQok7d1Zo79zn9sfv8sSViywszGEbFXJmmcWzF9g+2MPxfEgSmodH/NZXv0Gz1eEn\nP/8l7qDDpUuX2djc4Zvf/g4XLl/hT//8B5y5+CjXn36ONAERueiqoFTO8dbbb1Meq/HX/82/yY/f\nfIf5M8vMzS8xdFxUTeHFF75CtxeA0HjmiScJRIInVIrjdebnZ/C6TZwgoHnUpNVoo5kFXv3pW0xM\nT7N0dolKbQzLTDlsHVCZmuL+/XW+/tXfIQ1ifvbBB+y1e0zOj1OfGicJBJais7+/R6/b4crly6zc\ne8D27gHnr1zmscev4Lg9isUclcklzj/xAttrm7iDLrXZaQzd5Ps/+GecXl5gYWqSiakZdo8cli9e\nZHtvnTSNOXNmmpu3f8Xf/x//O85dvEDgxsxOLeAFKbmxOv/V3/uv+eDDj+g5Hgf9Nge7myzOz/Dh\nh59wevE0qYjxfYdm84iCVSKOAsLQZ2x8glp9mvJYjVyxwpmlZVRF5dKlRwjDkIuXLnHz1k2+9tvf\n+s0v4B/f33lFdooRJAlJLBgGMb7QmVs6z8zcPIPBgFuffUKnsU+tmCdnKpDIcWmUQKqaRECUCDRV\nXlQVQMmsNGNkF6UKMBQt88ZWpBJIyEKUZpaOWQqxHCuSSr13NlcVaUq+WEQ3DJrNhpQYGTooyNFn\nkmQLBEm40tTMTCQ58ZsmTVHFcVWQ96UpliFtN/M5G00Z5ThLzbAKxyY3o39pmqIL9bjbRKTomoGu\nGRiahuP5RGGEmhGqRJLlT6eKTGITCalaxMyp3Hz1e3iehycE1554jtOLZyQnQNeJRSyJTakKSvKF\n7vLXHege/tm/qCMdFe0vOO9lxyRJYkzDkB71mkoSyYxoXdGIMqKcruvHmesPM8RHjzfq4B/udo8X\nchlWrogUdAMllRIvkYhMhSZIkwQtTVE0UPVsvJMkx3nUURJhpAopsSTsoZAIORUiY9seT1KyQ2IY\nBl4YyOPHQ5atwHGkaSYLkyP0ECMFXA8RRphpjHBDYpFiVUtEQmCoOs2jFvlCntjpY+lCLgpVCxHH\nKFGE0+9RyJWI44Th0GW8VsP3XIRI6PUdivkciYiwrByaesIed4Y9hO9hGypaGqAQ47k+vu8xNlam\nNj2DSKBcKOM5QxbPLOD7gZRStVuEnouWKnS6HXL5HNWxcUQcky9WWZybo7m7Tew7kMZMTVYpWip7\nWzsUS3ny+Ty9VpfQ91HShFwxz+7+LqqucHSwRyFfoFgqomVMeUUBP/QxTAPPczFti9APJaSlqiwu\nzHPUaFKfnkaksLO5hqJqbO3s4LkeuVyeo8YhYRBSKVdwHA/H9ZidncEq5tnvtHiwvUmv10VLU56+\nfI1PPv8Vp+bm0RWVDz74gC89+xzNVpskFhQLBYIwZuC5VKpj7G7vcvnSBfZ29xgfH6Pd6pLLWbQa\nPbBKqIU8R602F88/ytrKbbqNJo9cXMQqz9D3BZ4/ZHFulh+9+gMuPnKBpQvn6TguGnlW11foDbv0\nWg16A4e9Ro/p+WWefvoGu3tNdo8O6bUbnFs8zd7eNgNviAhjOt0+f+2v/esc7DY5PNjl9Ol5ROpT\nLNl8/PGH/O3f//fR7QKtXpfp6RmuPXqF2/cfsPzEk1y68jin6tM8WNngVx//AjUNGTghj117jEGn\ny8qde1QnqywvnWfYGXD71qcc7e3xWy/foFK0efeXP+f9t35BY3efialp6nOzaELnjbdeZ2n5Miop\n55fP8fbb77G2ucnZc2fpHOxx/+6nTFWLTM2UAIVKuUZrEBAnNhNFnV/dXKXbbDAzUeaTD37O0e4W\n6/dlQpyqmEyduURhfIba5Dir924xNZ5nfrpKZ28TPIeD/R1qlTECV3q1T0/Os7a5wdXHr+MmCvZY\nlYn6HN1mh7nZaRDguB2GTof6xDhnFpc4OmoyWZ8iX67ihTFhHIOqUq2OkaQCRTOYmJ7lw08/Y3J2\nnkKpwlPX/wqw0D9fP3xFyUajpEomC5Kdiu86oMLM5DSnFk4RBRF3761QLpSo1GokpMRJLH2XVQUN\nIEkwdeOYsaykyGhFDVINgiRER5FyrqxYJxlZK1VGxZssXerETESkKYpICcMQRZFBJH4Q4HseSSrQ\nR3h35sQ2ummahqaoxCJB1TVIJdappEg8Tj15/HjUWSOIRUKqcJxiBsoXxrUgu7iUNCv46THpS9N1\ncsU8iogZDvrkCrljfFM3NJIkQFVVvEglJeHe26/R6XcZBiGXH3+ehcUl+l6IokljFi1VT1zffq0w\n/3pX/fD3v245+uuF/mScfpLudawlz8bUYRwfj9eTkYmNciIrG91aQwaDAAAgAElEQVRGHfevLw5O\nMOeMXIYMoYjjCFXVjtnkumETxglCVyGVhEMRJuiaJD+GfoSpmTieJ3O+U0DVMQxTOsFlCwtN10GR\niwhd1wmCIONCpMfn6HgCoYyY7gpRGMlCnghMTSUJApIowTQ1eu0uYaqiF/LEoUBXNVzPpVQu0Gsd\nYtk2sWIjFANdTRFBj9DvUavPcNRqyVjDXI6h06eQt4mjgFwuf6xhP2HrJ5DE+O4Qp98i8oeoQk4J\nXC/CMG02tzcQqdT+Ly6eodXpcuv2HZZOL4Gm0ev0qVQq0mhkcpoojKjXJuh0jrBtHcPQubtyl35/\nwOLCadrNNgVTZ3t7mySKaBzuUy0XMzzdIgoDypUqlXKRMJJkO89z2dvbRhGC+VPznD27zP37q7Tb\nbXRDR8QJ+7t7RHHMwHVoNJvMz8/T63TRdQPXCyhVqlTHxhkOZNFOQWZ8F/L4cUSn32NsbAzLNOm3\nO+zt7HLh7DnOXb7Eq6+9xsVHLlGr1eh1u1kwkkqaCAzLpFavs76xQalUot1uQSool8r4fki1XAJF\npd3tcXppmYPdbYgCZqfrHB21yOVLzC5cZrw2jmmk9NotAjfg6qNX+OX77zM2MYWhmoS+R6ff4uqj\nF3j9x3/J2MQs15+9wcr6Ns+++AJbW6sc7u3QabU4tXSGoevz9PVncf2AqZlZDrYPpF4/GpLLG6zc\nX+Go1eXcxUdRVYtbn3+KoWqcO7PED179Ic/euEE+V+D2x59z5eo5rlxeZm9nF5HC3ZXb6JpgvFLi\nnQ8/QyQGQzfA1CN0JWZ2rsbrP/4LPv7wNqW8yqVLl6hNnqI98Njf3WdmZhbTtIijiL/4839OHMPc\nwiJTM/OkqkI07HD/3gOeevoZqrVp8oU8p5aXMQyb80uLbGxu841vfotPPvqAjQf3Ga/WePlr30Sz\nc4xNzrC3t8/U5BRKIrA0mK1V2Vi5y0dvvcOzz73Ed7/xPK2jBp/f/IxYhHz7u7+Hlctz+ep1mgMf\nK1/E7TaZm57G9yPOnllganKCtbV7GeyZcnb5LJ7rsL2zy+REnXKxwr279/A9l4laHSUVaMi8g3Kx\nxHAw5Jn/n17o/0oU8E/u773ysI0lkF2kyawZlSxBTGOiNsnc3AKfffIJWzsbFHI2pWIBXVVJohA/\nkAHrURhIfaumkiSQxjEiSiT5RwElkaNfQUqcSnxXIAlSI00y6sm4c8RSUjkZ+5qmSSGfR1EV3KGD\n47rHpC5JFouOL45JNtJ1PU8S7JIUI2OMJ1kXKYQ0Bkkf6tJUVUUVEs2NEcc48qj4pSkyd3vkpqWc\nMLAjIal2ds6m3e2BArlcnjBO0BWBbugkiomqJnz2sx/Q7TUJ4oTTF65x4fJVnCBGUXVUkDrr/5di\n/HBH/XDU6sPF/AvjZP6fXbph6DJBTJzI0kYENakfl5h1koovbOtfto0R6ezhAj5ajCFiOepXspzs\njNBn2zaxmqCmKYkfoOsagYiIFUGumCcIfIqWQRQH2TQkJQpkl6oqglickO+EOGHoCyG+sOBQlJM0\nu9FzTFPJUdBVlTgMMVX52isXi4SRIAKMXFHCAKkM3RmvFGg1j6iO1QiFShgrmHpK7HZwnTZoBbrd\nNmeXlwhD2dXGoS89scfr+KGPiiZH/3HEsN+hXh8j8AbEgYupwVi5TG8wxDBsFNVA1RUKWRRoSsLt\nu3dIhUJ9oo4ApibrGJqRKQcSysUytmlTKuTY3tnmsNVEUXWK+SLFfAERhpiGdKVLk4hep0UhZ2MZ\nOu5wSBAG2AUbkQhM06TX6yIXQ4LpyUk63Q66rlEul+l22ty9fYdOp8PM9Azb+3t0ewO6vT6WZeMO\nBxSLFcxcjo3tbRwnYGpmhmqlSrvVQTc0DEPDGfp0O13coUveznP96ev0ez3ur6/heC5j4+Mc7O+j\nqiq9Xg9V1ZmdmcEZOghSNMOg0+lw7tw53vjZz1g+s0w+X0BRFFqNJpqqk8sX2Tvco1YtU7QNNFVh\nc/eQYZBy+tJT1OsT1Mby9JoHBI5Pr9/jwuUr5MtlDN2iVCwwNTXB0d4m29v7fOu3/zXOXXiMdn+I\naZt0Guvs7WwzPzNHu9OjUKly7fHHieKE2dlp7nzyK2Zn6rQ7Tarj4/yff/QnvPSVr3PxwmXiOGFr\n4z4TlRJFy+TWrVvUpydlzrum43t9SFI8N2bx7Dm6/S4Hu1sszp3CTwOWls4iUsFEweTB3Tu8+cYb\n7GzvEoYx3/3216mUSsSpRm1yFs8JmJmuY5bG6feHLJ4+y+LiMsvnLnF41GBpeYEgjPjRj17nxvPP\nYVg5QiFoDlzcvs+15TO88ebP6PgeQqR8+5vf5Ny5i/S8ACwLM1dApArr9x9QH6uiJiFrd2/zi7/8\nCc+88BWEWWWhLHkOlp3n3Xff4umnnufUqVO4oUZ+bJqtrQ3mKhaGpuNHMVaaUK0U2N/fpj4xzrDv\nkEQJkxMTVMpFPvnoQ0oFm3qtSrfdxNAULF2h3Wvj+ZJPpRsqT13/0m9+Af98/fAVeeHPyDypDLBQ\nsjdpImR3HEYCzwsAjaWlZXTl/+buTWMkyc8zv1/cEXmfdR9dVd1dXX3N9Myw5yJnKHJEUhQpUtYt\n7sLGrmx4tYJpWAYWAhbe+WZb8AK2sF4JWu8hS5RXxx5ai6K04jH30T3T0/dV1XVmVWVW3mfcEf4Q\nmVXVQ9KGsTBgbjQS1V0VlRmRkR3v/33e54CH9++zV9pBFImiOXUF23Vwg0h24/pBZI05DAANgojU\nPYqa9MJRMIh0RF4aQuWiEEHeI4MQQRAir+hjBdd1ozlxPB5HliRs06I36BOGYZRENQy08IfWmYqi\nRvN2QcAZwtuSEOUdhyM5lO9DEBB6IaEXRMc4Ym6PpFeHxSpE8KM0NVmSUBUFSQQ/9PGCAFGOnldT\n9SgRyXbQNA1lWNSCQEQSAm6//W3MfgvXDSlOzvHE00/TNSNDHXG4iPGGhicf77yPF9SPa6ZHRfbj\nnffo50fa76gwu64TLXi8I4WAJMlHH5Zjc/NRV378uY7HwDqO8xhhbuSMJohi5BceMnRhG2q3RQHX\nsdE8HzwfVZEjGFwcGsUMpWyW5UbzZlGJZI1+dH1s10UUolFQlBwaHjLaJUk6RiiUDxdro0WeJMmE\nQoDruCiKiGMPkAgIQg8jpiAg4AB6PIHnuriugyCE6KKI59vE4klkLY7v+5iDHna/g2c5dE0TXdNJ\nJ+OMfPDbnS6Fwhi9gYmqaTi2jSAKhJ5DNp2kVtknaWh4zgDBc3DtAZKsIKsqiWQSVTawXZtEIkFv\n0OPu7TvMzc6Rz+ZIZ1OIQki71ULXNExrgG1ZxGMGjYM62XyR7f19MvkC7XYbWRBIJgxURcK0Te7d\nvcPszBTBMLa3UMix9mgNxChTXRQlBrZNvVYjm0qSiMepN5sEQUCn02FiYpxYPMb21jYJI0YoSrRa\nbfrdHolEHM912a+UmZqawnUsyuUyvXYbEMgXCsRjBhBid/ukU0m67RaOZZLLZrA9l/lTS3x45SqG\nbiAhUK5U0PQYIZDNZem02yiaTq1exxz0UTUVRVaYmp4mmUhy/fpHFMbGqJTL2I5NEPrMzkxysFti\nc7vE8tlLPPHccxDPkcmmicsCGw8e0Ou0OLl8Cj2ZotnpMVaYhCCk1+mwufGQSxeeYiw/SSqVw/N9\n/uD3/zmvvPgM/V6PZqPJ5u4eiVSGdqtLt9dFVRQ00cb1bWamZ7h27RYfXLnOL/3CL7G3u0Uhn8bs\nNIipIu16Fc+1cQOPbrdLvdpAROSb3/wWTz37LGvbG6RSCTKJNHIg0ndcDD2B2TUpbzzAdwaMF/Ok\nsxmeefopUrEY3/3Od8gWCrz59ttceuIyybhEZb+GBFw4d5ad3V3mFhaptXssnLnI2ScuoAohvtPh\nL//qW0zPnWR1YxvRDZlJSdxavY+gxnjmuWfpWTa2H2B6Pp4gMDMxhSpJ4Pvoioo16HP1yrs8c/ky\nCxefwRhfYOODv6a0W6FvOTxafUgslkHWNNxQZu7EIu1Gmfb+IyRBpNFqoIQunU6DRqNGPBaj3+uR\nTqW4euV9Tp+ax/cstjbX6PdazM5MUCmXKOSz2N0OjeoBjYMqoefyyc/8R8BC/+D+9qtRkQuGDl0e\nwTCoJAhH2cviYdZyEAT0+n3SqQwnlhZRdZ2d0g7b21sEgUchl0eVFRzbipjbhoFLiBOGUVZsIOIJ\nAeGQVIQQzSIlgegmNyriQyc4STiaXRMexTKOCoiAgOt5yLJEPJ4gpht4jkun00VRo1hJaUii8ofM\naZGomPuBjxd4eEGIIMhDNvIQFhclRCR8BEJBHFqdHSdBRX7WQeCjyvJhVrgoikhy1DkPbecgCNFV\nFVkQsPo9At/DBxRJRSbg9pW3aFR3cUyPqclZnv3Ui3QsG01WIQhxwyP5lh8Ej7PCR0cUHsHixxGV\nEcFrJOUCDostjBZCzjDdLbogURGOrrcgRAhMQPjY7xw9//dD9/B4hz762ai799yIgY8oYFsWMgGh\nG82Ag1DCBcxQwBEF/DBEkzV8P8SyLX7z1d/gy1/9aYLQR1dlUjGdVMIgk0ygSiGnlhbYK5WIJxJY\njhUVbzhEAA55ANGZRJ26BBBi2pGxhqaIOE4PRZOQ8DEHfXqDHrFEEtt0UFQF2zLBcdjd2yWeThKG\nArGYgSqLlHf2GM9P0axXSSQMZFmm0+4hawad7gBBVpHlKOpWEAU0WUHXVTRFoN9roysKou8Teib9\nTgvX94ZGNSGSppHLFpAUDVHWsC0LVQlRtRBJlTE0jYO9CjNzcyiKimkOiMdi+I5DMpNhY3sbQVLQ\nNR3H8SiMT2D12/TNAf1+j1g8Rq/bJZNNY9k2e+V9VE3D0A36ljlMLGsNzTl8isUia+uPyGbTeJ6P\nKknkc1nu3btHJpthaWGBWrXK/t4eL7xwGV1VaNRr5FIJUqk4vW6PjfX1qNgqCs1Wg3giTiqdQghD\nsrkc9eEYQpIEFmdPEPpRoIrvBezslkhlM+xs75DN55iYmCCXyeIHPlevXOXll1+m2+1G6NEQPYkZ\nMSYmJtjc2URTFFRJpNbuEYulGBufYK9Sp5hNsbOxSm2vwsTUJPFsntnFk+ztlZmYHOetN18jDF1O\nn1smDERs00ZTNQ4Odum0quxtPqLVbvNg9RHxRBJRUchkUkxOjPPgwV00yaXdaiFKIn/6x/+KlZUV\nXnrheWrlPVr1A9IJnfLuNma3yVNPXyKbzZHNFVhZOcvY/CwXLz7B3u4GrfYBZ8+eIR5PMDU7h6zL\nxOJxZFnmj7/xDSZnpvjsF36Cp555joVTK2w+uk+n1+czX/wpBoGI2bfpD7qIUpbZ+Tl0I8qkqNYr\nEIQQiOyXdjm5tEClsk1/MCCbzXH27Dkmxsb4/f/9t5GQ+PSnf5w/+/O/IpRkZE3FHJhsrK0jBB6+\n5xCLxdje3mZrZwdJVXnm+edRjCTVlsPN7/4fZLMF3nrrTV555TO8/sZ7nDp/jpnpaexBn0xCJqaK\n1Kr7JDSJMPBoNuucPnWSZqPBifl54rEYk5MTqJJAPptFCAMy2QytZgPCAN9zGZgOQRBFHg9M+z8O\nEtuVu9uvRgze4BAWFoIwIhmJIqIgIwoioT/s7gQBJAHT93H8gHgiwcTUJGOFMWqVGg9u32WiOEE6\nnoQwpNXr4IqAGLGOJUEilI50uQBh4EWhH8PZnqqquG40hxWF6GYbjuRbxxjUR93dkFDnuoSBgK4Z\nxGI6nV6Xbrcb6bo1jTAERZbxPAfPsen3W4iajO35BIS4votHlJoV+V0LuMfCJghHsrRI7oQfDA1K\nohn6yDccQBVDRKI4S1kARQhQJYGYKhOGUSdj9S1Cz6G8dZ/SxgMCX2ByYopPvPwyHcdFlnQIBCzf\nja6D+Pj5w9HsORjC/5FyLMQPOOQyHEm+xajbY8QMD/ADf2j2wnCnaGdhGCYyMoQ5DpFHNukRKzwq\n+Bx+HcHRo78fSseGASPi0EhHlGRCAhRZxBkMyCYTVMslYrkseipGIptAliCjGyQUmYyhYg96fO9P\nf4/nX3qRnc11Krtb7G6ssXb3Ntfee4d33nuf73z725T2d3niySexbBtJHIbTBCCKErZtDUmFUfdt\nWoPDBDJFUTC7XbKZFI7ZQ1EVVFFAVeVo5h0z6DY76MkYtmMjex6bpQ1Wzq3QbDQRETAHParlGotz\np3i0cYdsNosoq8STKYxYAlU3iCdTrD96FPl7OxaN+kGU7y1CNpvGNgdY/R6GJuF6kUTRcaOboCCL\n6EYML5Dp9zyymQTXb7yHKJhk8+Ps7e4xPjFNIpXD9kNkVWdt9QGKEjI1PcPq2iOmp2YRBYnN7RKn\nz1zEs5s0m02qtSqKLKPKMqqm0xv0GFgWi4uLZHI5bNuOXOBiOjFVp7SzgxcEaIqC5Vh4nk8iFicM\nQ/LZHN1Oh2rlgPnZOTKpFPvlvSjO1w+xB22SyRRjY2PYtksqnaXWrNNqt/Ck6P/izMwM5mBAq9ki\nnUzQbbRoNds4tkuz2abb66EZOosnl2i127TabXwvkqvGjTiCKNLtdslms7Q7HeKxGCCw8egRcyfm\nsB2HbrdHLlug3moRMxLIQYDohsQViV6nTvWgyhNPPcvqxiYIMhPFIpbV4eHqbYqFDFMLC7Q6PYrj\nedY310inDBYW5tEMjcUTC3x49QN0wyCRSnL65ElEMWTuxAx3r9+mOFYkmYhz49aHnFleotNo0Gt3\n2FrfoN2p8tUvf5GBOaDX7yHJGj4KSjzGTrODJCp89M4bvPDcczQbPerNHnoqSbVWotttclCt0HdC\nFs+c5drtB+TG56g3B6ST4Ieg55c4ef4ZOo0DvvBTP4sVJNjZ3ycg5NyFZVRZoFUto7kuqVgUWNPo\ndalW69z88D2eeuZJGn2LJ597mhvvfMDc3BIzJ5bY3S9Tq+wjh1Dfr2BZPe7fvcf6+jpTMzNkC0Uu\nPn2JtY1NRNPGN20eXPkWjfoB9WYVxJBqq8tnP/85PveZz7J69yYxVWBzc4PxsTESukgslkQSBPrd\nLrXqAWdXVqK8d13jww+vMT9/gmq1hmu7ZJI5bMfj9KkzbO4fEMvkSORyxDM5nnvu2R/9An59rfLq\nKOFrtIlE+c6hd5TNHD2ijsUPgyjQIgzxAh/X9hBFhanJScbGx7l9+x71RhPNkBnL55EFCDwHEQE/\n9CAUDuVfUczmCDr3kGRxeJOXIIyOIzIiOQZlh6PiFEmnRt7twjDuMkISAnTDQNNUTNum3e0QepHm\nWRF8NDng4oVTGKqGEAqoSmTGYsQU4ol4BNuKIIsiiiQihiFicOz98KPi5AmRTMz2fLwgMrxxXH8o\nqRJw/Siu0/ejYA9JltFjSXxACAV8z2Zr/QE7G/dRJQ1J1Hny5ZfpDANj8MEXgkh3Lxx1uD8MGj/a\nhMf25VgHfTy4BEazc/GxohuGI3MWHlswjbTej2mqw8c92I9e8+i4jssLBUHADfwoRU6M3KsIAsqV\nMjtba2w/uM/dK1fZuHadG+++xXvf+w7f/LM/pVsvowoCV+894saDNTrdAbdv36PTHZAvTJHI5Fhc\nOs2ZlbOomoHrDaVswRE3IUIVIvqkIEaLVd/10A2DMAiRBYFOs4FnDSKWdd8cmgQ5yLJMr9NFMXR0\nQ6dXreLiURgfo9/uoUoig0EXCBgrjFOv7xJPpikUx+kOTDwvQBim6G1ubFLIZeh32qiKxNjYGKY5\niCJaPZdmvc7YWJ7QD9CMOJVKjSCETD6PZTs47tAXnpBabZ9CPk1pt8H0zAK5sWk6pksgaUiqQRCE\nlPY2SKeyBF7A5PgkjVadTqfL8ukzdBtlBmafUmmXpcUlAs8jkYjz9lvvMHfiBIYRw3VdCoUCt2/f\nQggF5mZmsHoWnu8zPTVFt9NFRKDVatFqNun1e5xZXsaxbRzLjUhqtsn21iYnl5YIQ4Fms42saCDI\nJDNpstkUfuBi2japRBpZlHBsl0azTb9vMjk+gWk5jI+PY9s2yVSS3mDAvQf3WV4+hSwK7O3tcufO\nXRzHIZfN0+60qTfr7O7tkstkCIKAfDZLtV5jfmGRR+ubxLQEuWIOGYmxYoGHa6tUKiXa7Qq5dJLu\nwGRydiayf02l+Ku//BbTUxOkEik6zQ7rj9aQFJlOu0W71WBjfY3Lly8jhHDj2keEIRzUq7z0yRdZ\nPnOaWrWK70Tvp6YrbKw/oljIk0okWVpaQNN1trYeERLywic/STKVo9kxSWaKVDt92n2buBanmMmi\niDrj4/OcXFrm4YO71PZqvPnad+g3W3zlF77G/PIpTp05Sblc5ubNhxhCm7UHDyl3BQJRYSqrs7ld\nZX4yz9z0GKsP7qBoCpvbu5xcPoflBnQ7dVYfbbB0+hSff+UV7t68znfefI0vfuUXSGdz/NX/+S0+\n/crnGJ9bpDg2zqDTZn56khML8xSKRcbGily48AQnTiwwsCz8IEBWVabyBcxOA7dbwjIHCGLIo41N\njESWhZOncEyLfDbDoNvGCwLarRbFYh7TtOn3+0xNTXNy6ST75T1836VWq5LLFmk2W1QPapxZXsH3\nffbKFc6snGWvtE8+k8Hsm8iizOXn/sNY6PL/8y7/32+Oaz8GdQauR4iAIklookIQBOi6Ht28RQFf\ngK45QBgGU4SIhAI4oY9jWgQhzJ1dIabKSKHH/u4WtcpBtHrPjzMxMYWkK1h2f0iQkqN5uQAg4Vku\nYeggijKqquIPIV6IVMDHi5AoilEX6Q3DM4KjEA0E8F0fEEjoaVTNR1YUAs/GdSwunDvFP/mdf4go\nxNEVHUXRopFBGOmgQ89FFEUe3d9GS8XxEAgEEVmUSMTiFHI5JhZOMjk/C5KI6/o4joPn+YR+gCeJ\nh6ZhQihCIELoI3o+2G1ABkVBQmN8bp5CJo3kqbQti25vgJHM02sOkEMJJaHhDyxQIkOY48zl46jE\nUQF9XDIVFd7gMeh79DziMDp1tP/xhUEYjnzKj0Py3hCWf5xUN/q949fneCDKaJ+IMT78fhCFhqix\nBGIQcHp5JSJMBSqBr1CpVDio7nPp0gVMz8H14De//sv85n//P1FqdXjjrXf56Z/5ZXQULNdFkuXI\nZFEEywVBVA+NbGzHRdXkyAgmANcTwHeQQtBVnV61QT6Xwg48PAQkUcMQDWJpGbvfJROLRTeIXJF6\nrUqxmGevtI1oGLgDj3Q6TaNeQRMFAruPJHvMzM3hui6qFBKGPr6gYqgKQb+J7JuUS1vML5xAjyUi\n2Quw+uAhc7OTpDM5+laIki0S9m1WLlyi1mlRLlWpt1tYns+ZsyvENJ2x7DRvv3aFH/uJn6RebxIv\nLjAQNQQkzIGLoicYmzvHTqnC9Q+ukM3Eefv17/Hpl1/G6tWJx1LIksZHH9xAkXROP7HCn/zJH6HH\n46TTaYx4DLM/YH39EZlMhmIuT+WgxtKZ09y48SGyLJPP5eh0OpGFbDaLJElcv34dTTOYmpqhXKnQ\n75ssLC3T6Jg0Oj12t/fwH22Tz2RZWlrig4+uEE/GGC8WsPoO5VaNqakZkpketUYVKZUhBWzulQDQ\nRPBNm1defIn7Dx+wvVviJ774RTY3N5FFmV6vQzwep9Pr4DgOfcvEty2q1SqypFHZq3D+7AU+unGd\nixdWAJFmr4GoB5x74hRbG/dxXJM7tx7wlPwJ7ty8T2NylonsOEk1jorI2sYGguuzv7FNuVwml8sx\nNTPJX/75n5PUDCanJtjY3kYm5Lvf+WuWlpaYm5tFUyUMw+D3/sUfcPnyZfK5PBsbG8TiKvfu3ebl\nV77A1fc/YHXjT1lYPI1ixAl6JlPTM0xLMgelEvvb92i1WmiaQTppMBjUmcin+NLnX+L08kU8OUWt\nP6De6JBKj/H5L11gwt3l7gcfcv70CeIpg9mCzHvXbvFRcwNJ1onHk3ieQjY3R7vr0w8FZEXlJ7/y\nZa5cucJfb73NV37xP8Xsmfy9v/N3+MpXf4GVpy/x3s2bfDo3Q3m3zMLJU7RbNQxBotGok89m2Xy0\nRrvdZm9/n1gijmqo3C/vs7dX4YVnnuHm9TtsbW0jEPLR9du8/EoHaVFkbW0N33HJF7J4rsX7V6/y\nyedfotPp0Gq12N3tMj0zTrfbRVEi74pMIo6RMLi/ep9MIklMU+k7FpImMjC7BJ6J2av/B9fO/190\n4Ffv77wKR12UpqjIioIkRfBdKERuV47n4AY+iOAF3iFsevi7wRGcKysyjuPiB5BK5CiOTWPEU3S7\nXbZKO3Q7LcYmiiiyhGU5kR/38PUlWR4alYS4njeEcaNMakmWDr29ERhCwKOZ8OEI95C1PioysiAd\nysJURcEzLSyzz3PPfQJDj2EOzMjz3QmQRIWEkSKhp0jFMzx5+TJnL15kbmGRpVOnmJiaRNM12p0O\n9x/eZntng4ODKP83HlNJxnUShgqCghCEuK59lJ4VBAhCAKKKHxAZr4Q+pY173H//ewRu5AsfL+SJ\nZ3PkUzl810NQpMhN7GMd98eL6OjryM70cWZ4eOznjzPGjweQPP54vOAfvZZ4KCU7/trHN8Mwhs99\npBUPguCQ6DaS7xGCGEZWNH4QULccuqZLvedEmk7X4d2rV5mYmiEIRf7iD3+Xn/+bv8JffPt7XLz0\nNNl0BtO00HQNX4hsbxlOAjgUJYYIonQ4/kAQkUQ5kov5Ho5l4jkWrdoBk5NFfN+l066STBhcv/YB\nmiZi6FpE0PRD4skE9VoVKfDp9/tMTE1hmiaKKFDZ20OVJZKJOPGYwW6phKZpGIkUjuuiKRKNyh6i\nIJJIJjGMOAEC/X6XdCpJo1Yhlc5gWRbrj9ZRVJVB30TWNNKFIuagj+NGBEHP8xl0B1w4e54b12+z\nXipRLI6xsHSanukQ+lFUaxi49HstPLNPu1FFVhTefOsNvvD5L7C7vUO33SSVTlA9qHBifp719XU2\n1tb48pe+iDkY0G632d3dZXt7m+XlZXZKJdLZFIoks7e7GxMLWkQAACAASURBVGnAFYWYEaNycICq\nqiQSCeLxFEEQsLG5xdTUFMlUihs3btHp9lB1g0QyCSE4jsteeZ9z51YIw4B0Ks3q/VXGx6YYGxtj\nv1KmM+jTHQxotRrkCnky6TTJRALPdqKxm6bRH/R48tJTbG9vMzM7i23b9Pp9jJiBbdu4jks+nyWX\njcJAsrkcnh+hfqsP1wgQCAIXWY2zWyrR7bSYKI7T6Q/Y2tomly+SyWRJphO0Om1M1+TR+hpBKJDN\n5FhaWmJ8vMj6xjq6ZmD2uqycOcvG5ga9gUVMU0kmEly/9hH5QpFkMsWVK1d45bOfIx7TaTRr6JrM\n1tYWUzPz2K7MK1/6CrKuc/fuTZ48d4ZurYpvWbz12l/T6dbp9Fo0umXkmMQf/qt/zfLZ05x94ik2\ndirkxxYY+AFGPIahqyhSDMNt8pff+ibnn32Z0u4uqt9jde0h559+mkQmRyqdJ5UpIIkKkiRQyCdx\n3Sic5/nnn2PxxAKra6uM5Qtc/+gaH773Ls+//Cwb25ucPnMa17PwvD6EEdLRswZsbu4wOT5FuVIh\nmU6gGRpzs7O4ponVN8GqMjkxxfrmI3b397EDiUQyyYn5E+yWSggEdHptMpkMhqETBvCpT30KVVX5\n4IOrtDtN4vE4giCiyBLJRJJWp4Pv+yiSRK3eYHZhgfJeiXariT0YYPa6fOYLP/mjD6EfL+ABUQFl\nOGu1fJdAADcM8DwPj6hgeoE/dFiLSGQj/fZofuoFHpKiIggalgOW66PpcdK5HIXxIma/w25pGwTI\n5vLRvHaoMXaHhVqSlMi1KwiR5OjvovB4QQh/SNE++gMhIo5pIamRNty2bHRFwbZtJqemOHdmhpnZ\nScbGigiKgBLXyU6MkRkvkJ8aQ0tlcIKQUJIw4nH0WIzxqSlOLC5y4fwKItButnh47x43r19n49Ea\nlUoZBAnDUMmkUhCEQ2tZh5AAJxAi5MH3UcWQ2x+8jTSoMuj2CAKfnudyUGugaTHSqTSBKCIIUhQE\ncpyI9TGS2NH2/bKxwzfo2PeOIO0jD/TDZxCExyD7x6HxH643hyOFwA9yRQuHA/LRtQuH6WKRi1+A\nIHkQ+CRjOo7dJZNQmB7Pcv39N5nMJ3n3299k9vRF9FSWick5et0eqirjRV5qUeGWYJQmjjD0uA8j\n2VkQBsPzjcY2iixFCgJZxOx36bQapDIG2+sPiRsKjUqZqakiYejT7HRw/YB8oYCmyLTrB+QKBTLZ\nLLVaHV2R6LTbJGMxFFlirDjGYGDT7fTIF8YjsiVg9ppYgx7ZfBHT9ZFklUwmjSLB6r3bzMzNc1Cu\nkMqkSeZzTExM4wYCeiJNTFOYW1hAlmXu3r/L9MQcpumyuLDEP/rdf8KTTz7B0ukVTNsl8L3I2jfw\nSMdV7H6X8u42A8skly9w9vQZhBBsq08hn2N19SHz8/PcunWL+RPznF1ZoVQqMbBMVu8/YOnkSfrm\ngDt375JIJFBkmXazQa/XRRRCXNchWlsL9Hv9w89hoTiG4zg4rsvU9AyzszNs7e5hmTazs3Pk83nK\n+/ucO7/C+PgYV969wvmVi4Q+tNptJE3G9X0OGnVimgpAJp2m3+tRzBfodDr4gcvpM8s8erROsRjB\nqKVSiUwuiywrTM9Mc+vmLcYKY4iCxNjEJDdu3CDAJ5fLMjE5RblcpbS7xxe/9GVKO9s0mw3azTYD\nz2d2Zo54LMFBo4YbeEi6jA9YZh9BFHjq6U+wv79PubJP3IghigLtdpOJ8QnqjRqOZZFOpXn22WdY\nWlrkuRdf5Bu//wfEjATnzq+wv1/i1MkTWJZJv9NF17OcOf8M2eI4fuiRjKlUd7aplcrcePNtXLPK\n2NgEgqvy4uVP8cbrb3D+/Hmeee6rVKomudwU165/RDqTZmH+BCkjgSjJ6HaDB/fvcvkzP4GqyLT2\n1wiQ0AtFcvlxZDVOGEp4rkfg2fheD9sXyGZSTI4XeLS+ge8JBKHAzvoq24/u87X/7G/w7nvvcubs\necIQtnd2UCSFsdw4129dJ6En2dzcZHysgCCCIkWLaTmMzLpku8H16zf46MZ1FD3GfqPHwuICn/3s\nZ9nfK2Ga1tAt06Pf6WGaFq+99hq6rnPixDyOY5HP5xFFAdO0kERIZlIEQUhlfx8nCDh38SIH+/u0\nGnUatSp/82u/zPj84o9+AX//zvarDIswYcRyjuwuI6Z4pKkNh0lUwiGTm/BYER2ynUd50wgQBhHL\nXBCjBDA/8HF8F9f1KBaKCJLA/n6Zra1twiAkEY8T06PVVRhGNpeSJCEqMgPLHC4q/MPSHBwrLMHH\nJFaPs6/DyEd6SPRSVIUwiM5376DGTmmfngWCEkPUUkiJHL6s0bZ92pZLrz8gFIRDZMD1fBzXw3Ic\nbNMjm8tzaukUFy88wdLJU4iSTL3eZPX+UUHPpJIkk/EoPUqRkCURz/VADJFCn1xcpF/ZpFqu0Tct\nvvLzv8gLn/5xBFHDtGwEObJ3VZRo6jKaYR8v4I/D3N/fNY+IZdFsPBgW0Md19h8v1iN52Q+br/8g\nN7bD68FRpvjH5+NAZNwzOgcitnlASCAKiJJKIAp4gY8X+MQMg+mJcbbXH7Fx/zovfOaL5CdmMW0X\nSRCQBAHPdYYpbHx8/RKt78JRCAzD9y4kEECQI/WAPTCZmigSBDZ7pRJTYzkUISTwbJLJOIosMOhb\nUexrLAG+T7dVI56Ik8/l2d0pkc/nqOztkc+muX3zQ4rjU3RNE9v1SOdyCKJM4Dm06hXCwGHp1AqS\nrCNKEr7nEPgWmWSc5sE+qUSCWCKFZGRw3RBEmXangx4zWFtdJx6Ps7iwhCqpJFNpGs02eswgkYgz\nNnOCZtdG1TQsx0HyLQS3z42r77O3s8XG5jo/+/O/yGBgomsarUaVWCJGuVKh0+myu7vHxSeeiFAF\nVUXVVB6urbFy9hy9Xp9EIk7joMZYsYBtWliWhW0NaLVaNJstgiAkZiTo9zs0ao3IWU1Teeedt0mn\nk9h2dGyVvT163Q6FQp6pqQk2NjawTIuxYpGHD9aYnJqk1x9wUK+SSCVpttsszs/RbrepVg6QJQlD\n1SItdTpNLKbx9rvvs7KyQiiKpLMZcrkcuq5HC4ow5KBcYeXsOVrNDs12i06nzbPPP0s8HiedzqFq\nSfK5NDduXmNvd5eTJ5d59vlPYdkOsUScK1euEA7zCfYPKvhBwOLiSdrdLvl8nrm5WXzPYWB2mZqZ\nolavMzs7h6LK3H/4kK989aewHRNRCPmzP/smL7zwLEIYIisCA7NH9aDK6eVlPrx5i8989mXu3b7G\nlXdfY6KQ483XXmd9fYOf+aWv8mB7m5/92q+wcvYiv/bf/Ncsnr7Ir339vyOVHCcIYKyYp1kr0xsM\n6DU7ZONJKgd1knRw7AEtVyKeTLB1/xYPt7aRjTTVgwahH2KaJlEKnci1D6/yzHPPsrO1zpMXL3JQ\nrdPouSwsnmZl+SSd+j7tXptypYbrK2xsVzBiKayBy95OFXNgcebMPOX9HSzTZGpiEtd1qdYO0CSB\nu3dukcThO999jUq1hWroNE2bRDLJuXPnyGVy9PuDQ2Q48AOQQFZUVEWh021SKOTp9/s4jhORi8OQ\ndrdDt9tBCKDV6bB46hT3795ibHyMyckp/uhP/oSf/oVf/tEv4O/dLr0aYY4RkSkig4+YyBFJLAxG\nsKk4tMCURsDkscJwZMSiSAoQEgqRpjwIPYIgmvGJkoxpORiJGFOTM8TjCbrtDuXSHrXqAXEtRjwW\nw/XcKP3L9xClSLsbQa3CqOw8VnAEjljRH7+DB0IIo2St4YLCC0MEWcEW4/Rt6FkhPip+KCFJGnEt\njippuL5HEIRYlk2/PzhkUXuejyCrhEj0ByZ900aSVcYmp1g6tcyFs2dYXJpHEUXefuddPrp2jfXN\nVcxBF0kMyOej2Me4ImF2Gzy8/h6lvRq+JPLMiy9xYvkCoaChaAbdbjfqbo6RzkZQ9HFnsaNC+YPN\nW2C09hKGurRh/OrHiGdH+z8Oux9104+rCD7uDgcgy/KQTOgfm7UfHYOIMEw0iwxNo0VJiB9GCWV+\nKOAFoA8NODRFZn5uhgc33+HFz/4kHStCefACVFFEEo8Wk5EL0NFnQUBAFqVDNn0QhoiSgCDLWJ4z\nVC6o9HsdMskEsiSwt7lOOpHC0BQOymUK+RyO66FpRjTO8H16rSoCAslUilarRSqZYv3RKksnZvFt\nk3i6iKoZ1Go1DD0OiMQMlWtX32VpaR7HDSOTnxDwPXRVonZQZufBDc4un2Vnr4qem8SxPDKpFK5j\n44ciO6V9JiemiRkx/s2//XdMTk5x7vwFbt/4iI2NTZ56/iVMX8L1fQLfo18rkdJkHt65w6NHq7z0\nY58mVxzH9wIse4CmKVSqFTLpNP/sn/8zTp46xaWnnqLVjCRskiRFMqZsjqmpaQxFRQxCFFHG8236\n/S6appBMJllcXKLRaAACljUgnUnT63WRZYlEMoYsimxvbhE4JrMzU2xvbDJeLOB4HhcvXmBnp0Sr\n2yaeTLBb2mV6ZgpBEun0u0yMFblz+3YExyei7PJuuzl0XgxQNY2Tp5a5dfcOrudhWQ67u6Wowy+X\nObdynhvXbzA2Ft3EEUXa7WY0miPg3r01fulrf4tvf+ffMTVdJJPKUy7XsX2Pk6dPsr+3j6YpjBWL\n1Gt1+p0uIRKTk9OcWT5D4PmIAuzt7yBLUG83MU2TDz/4gJ/80pcpVyt0+j2y+Tx/+kffIJfN8Ozl\ny9i2RSymYTsmM7OzPPHEJWYXpvnud7/F229/j1a9hu/7FAoFnnrmSaZOnqRtSZy68CS/+vW/y7kn\nn+Rrf/u/pFRrEDc8pmYLvPfOm5w7+wSSqlNvNMDz0HSd7VvvE0/GmFg6j2lZ3LvzEYKe5MLKJUqb\nO9EoJKZRq9f46PoNXvr0j1NrVGnVDxgr5DiotclNnGC/2iCTTrG4eILf/73f4eCgxt/627/K8vJF\nbt25w9mVc8QTSTLJDImkj6EJOJZD7aAxTI7bpFk7oFjIkRQ9vvf6G5hOiBLT8ZAYK07w/HPPc1A+\nIPRDRCHEHphkUmmyxRxh4OMHkVmRqiqsrT5EUVUmJsaxTGs45mqSz2ZxPJ+Ty8u8/fZb/OzP/Ryv\nv/E2/+L3/pC//+qrP/oF/Mq9/VeD8CgxarRFUpuoYAbDxClhmLctjIr7x6HbEAgju9Po38GQCOUP\nb/DgeyGirBCGAb1eD0PXyWVzZDMZRFGgvFumVq1QLBbQ1Mib27HNIUFNjo4zZBjVCQwXFP93WzDs\nuqQhdOMHAQgisqxC6CNLIkHoAx6ELmHoIooBBC6qbkTSGjXSqUazx0jP7LoOlm1F5i6yhI+HPUyW\nEoMAWVKYmZvhyScvcWJxAVEU2dnZ4fbNm9y9e4f9/X2sbpPQ7lHfW6d80CAUZfpOAGqCP/m3f87p\nsysYug5w+L6OZsk/zMTleMwnjMYKP3gbFdDjsPxRcf7+Ij0q4KPX/fjrHLq2+f5jBfvwWgTHHOuE\nKNXtuHe6LgkIgYsuCcQ0mUatQuCY/M5v/UPe/Pa3qOw8YG27SqDqzEzPgxcgBJH0Lxx6FTCC7jnq\nvmVJPnS0E0URz3ci6Zws4QzsSJ0ghvQ7nSjhzrHY2djk1KlTrD18wPT0JPVaFSOWRNcNOp027UaV\nKIxVoFgssLdfpt/pIIsBYuCTn5glkUqwvbHB7PQ0CALbW+vIkk8hF8lbjJhBMh6n027i2X3sfp9a\naQtN08mNz4AaR0RAGaaQ9U0b0xywfPoUkiCxuLTEu++9y8PVh3zm0y/xL//4j3n2xZdwkRAIokSz\n5j7ZlMG//MY30HSdn/2lv8HOfhlREFBVCU0Ec9Anl8tx48Z1nnjiSWZnZ+l2OpjmgNXVh2QyGdrN\nFoN+H0UU6bU7+LbFfmWfXDZDr9en0WiSTCYxjBipTIpWs06ptIs/RNPisRgxwyCVSpFLJ9A0jbGx\nAplcllq9TiKRQpYV2v02QRCSSMT53uuvo2ka2WyWifFxstk0W1ubKIqEoWtYA5Pl5WXWN9fp9Hos\nLZ9BM3Q2traYmJxElCROnzpJr9tFFCXqjQatdpuBZZHJZGi12+zt7lKr1ekObBLxLL3eAdc+fJ+f\n/7mvsbh0kjv37lGpHKBpKqHv0e90kQSBfDZHPJFkt7SLbbkkE3Fu37nF1avvkk4nSOXypBMpYkac\nO3cekMikmTuxgKrp3ProA1555QuUdvbI5jLkCxlOnlzi6ac+ge8LvPnWe9xb2+DU6UtcfPJFCsUZ\nPvGJ56IZc99m9f4j/rd/+ruMF4v8D//j/0yl2mKvvI/nS4iqhut66LE0ghrD9yBmpJicLED/gHJ5\nj+LiWbZLu9y7eZ3lJ57mU8++TKfTodfrUK3XCAh55hOX6fZcLLPDxHie+dk5ao0ugprAckM63Q6F\nfJad9RuEnke33aM4VuT9K29x6vQJPHdAtVxBkQaoqoSITHm/jGFohARUy3ukEippRUYxDA6adcJQ\nZuA4TExM8uILL2D1ByiyTKNRI2YYNOp1AiFkemaa6x9dZ35ullq1QiwWcZlavQ6+6+KHIfv7ZSby\n4+hGPMpsDwJu3LzNP/7t30YzYvy93/iNH/0C/v7d7VejMIfH7TojKPQoAtT3veFMcTir/AHEpdHv\nHzlfjeaNI9Y0SFIUYOH5kSGG67oRFCtAKpVmYmIcRVF49GiVdruNpiik4glUScZxgDCavYd+SDTi\njNLMIpbYD9kEAVVRcB0nCjgJA0Qxgl0lBKQQQt+LiFmyghdEULkoRuSx0SYPc88VRUFV9CgVSxBw\nPRvLNqNz8fwo4cwLGJgDugOT3sBCFhVmpqY4e/YsZ1YukM+N4bse77/5BjHJI+jXabZ6hCJMzy0x\nu3QG0ws4sbiE53pomnZoB2pZ1iELf2RZOoKthyf8/+5D8EPIcT/gEh/u/v3M96MCPiK4KYoSFUvP\nO/KJP0Z8Ow63jxYHrhcZP3S6bSqVAwQgcDwGnQbT43mEQZ0Ll1/izPlLOH6A4A8/c6ryfUl4jx3z\noZ3LEGlw3UhqKOsEvo1KiOg7JHSF0HfJZ9PslXaYm5tne3uDmCZjxPQo+tSP+BjOwCQej2M7FrlC\ngU63w+z0NK3aARI++fEpWq0GoWeTjMcJA492s4augBuE6LpOMh7HskwIPfKZNI8ePmBuaYHrN++S\nK4zTs0wC28J3HcbGx2g2q5iDPpIo0Gw1EAWRpy5d4vXXX2N+YZ61Bw9wPJ/Lz34CQ4F+t0lg91Hk\nkBsfXeNzn/8ihclpQkGkVa/jeSaaFCCKkE7FKO1sc2Z5mTD02dvdZnZ2ktu3biABtXqD/qA7tFqV\nOKjsUyjmWV9fxzBiaJqOOIyLvX//PmPj4xhGjGwux2AwoFKt4Lo+8VgMVdOIJ6NgIkQJVdXY3Nzg\nxIl5GvU2nXaLixcvMjMzS7vfp93pYlomiwsLWJZF9eCAbqfL2TNnuHPnDolknFQ6TbXZQpQl+qZJ\nrz8gnUohSwrVShXLcuj2WlimzUsvfQrfD7h3/z6O49HvO+iGTi6X46lLZ/nwyjVqtSYnTy+h6jrW\nYMDBwQGDfg/Tsuh0O2i6xlixQOgHDPo9er0ezVaDEwvzyLJCo9Ukn8mRzeT57vfeYHt3n/nFExxU\nq8RjCZ67/Enu3L5PpVKh3apTyBf4rf/lt7hz/TbIKT7x/I8zPrvCp175Is12n5u3biGIEjule/wn\nP/PTrK6u8/Vf/3VK5TKilkDVMhixMfxAIJmIk0okaHW6nJibRxZETLOL6rcjB7vsJJVymYe3r7Gw\nfI4T8yfR4zG8MGS/UqXebFOvNcnli3h2n36nydzcLJVqA9VIEviRP0K5UsZuH3Dm1CLb6w/Z2lrl\nySeXMdQQERshdNnZ2mFvdx/LNMnls8zOzbC7t4s76CNJPqX1NVa3NpE1g263T6PT4/Tp0ywuzGP1\n+/i+i++79DotMpk0ohZB6YZuYJmDyOBncZFWu4XtuviuR6UckUG7zTaNRpN0Psf/+tu/zZtvvkmz\n1cV3Pf7+P/gHP/oF/J1bW68edVbBIXt3NP987AYriUOTkCj56zD44tgjDMMjkpsgEXoCBAKiFLlO\nRZ2wgCiGhASIooQfCgQB2K4TWT8m4uSyaRzbonpQoVouE/oeiWR2aFcqEvhRelRktxoMfbV/CGwc\nhoR+MMz1DqP8bxEkQcIVfNzAHZqxRFnTkqgiiyr4En4QycncYQGKTGWi15EECUmS0VQDXYuhKTqK\nqKIqOojDc5ZEBFEGBBzLptNoYbkSyWSWuZkZXnnpRVZvX+OjK9/FD0SqBwecPf8En37li8yeXCZA\nQBKlw/dXVdXDou267mG4y+O662OFavg15KjofpyA9oPetxGJ7ePfH0H0o+0xUuHw56PuewShc4yx\nDlHk60jQLx6zYA2CAN1QqRzsEwY+uVwOTdWwzT6fvPwMquiTUQKKM6fITM5ie+Ew0lbAG45ofpAm\nXRSHRkVhJEUUwhBViEY9juvhWwNUMUD0bPqdJpqi4DkD9st7LJ5YoHawSxA4SJJALlcgFER8P6BW\nLhMEAZquk8nmOKhVmZ2exDEHpOIGRjKNKAQ0qxUUQaTTiUhynmuysHSSuKFzUKmgqmoET+7tQRhy\n8ZnLNFu9CP4t5EloOq1OG9t1Ke+tYw76rCyfQUBEDAU6rTYXz5/jvasfIIkBO6UdPvPyy7hmD8ex\n0RQJ2+lx8+ZNfvxzX6DvuFi2i6Gp9Nt1HLODbZkkEwkajRqKIlHIZ2nWq+yVSsgCqIpKGAasrT6M\nFva+i6yIzM7OIEkStWqDdqfL3t4uiALZXIZ2p4umR7N1IxZD1zRqtRoD06bT6dDpDQgQMOIJdMOg\n0+7QqjdIpTLYts2ZU8sIkog7lCSuPlolpspMToxTKBSpVWtMT05GLH8jhhE3sD2fysEBN27eJplM\nIoki+3v7xAyDdDqDokqUSjtcuvQUN27dot8zEQSRXG4SPSazunaf7c0NXnj+k1SrDd54+zvMTJ9g\nZWUFVVXZK+2h6hoTk5MR8hYGdLtdGo0WiUSCWCxOu90hZujMzs4Q+gH9dp9K+QBRkrh+6w5ra4/4\nz/+LX8W0fDzHp9Nuc/78GWQBvv2X36FZb/Mrf/frhGqC7b0yduCQLaSYmZ8iP5anXuvxu//0H/Nr\nv/Zf0TND9ER2eM8N6ZkNBMkmYch0m10UVcYadIlF0ybauw946523eO7HfoJsNsPVt77L3MIp9hst\n7t67TyKd4ZOffBnX9cjni5RK20xPjfMX3/omL77wAncf3EeUVHw/oN1oMD5R5Mrrr7H+8A75bBLP\n7VOv7fHRh1eRCBAkF0NJMz+ziGObVBv7ZHMZGq02Y/kMg36b8ydPsra5we5+hUymQKPV4NLTl0jo\nMSyzTxj4pFMJVDVyYStOTiEKIoqsUNrZJp1K0ul0kCSJfLFIOpmk2+thOy7ZZBZN17l99y7//t9/\nm0HfRAKmxif4+n/76z/6Bfy9O9vHDkJ47DG6gR9CpSGHjmTHt0NIdLjfCLYMwwCEYVyk8LE5qyAB\nUkQ2G85ixaFLmxeGeAhkcgXGxiaRVZ1mo83uXonBoIcoBiRSMbzQj6RtsswohEREQCZKn/KHvmoy\nIEjR6wTBsKCGQ1MPxKHb25DdPYSOg9DHD93H/L4Pz3uUUCZE53j4GLKeQyEEIUolk2UlslaVJURF\nQTZioBh4go3pDtBVkffe+mvs5gHNVhNXVkllCpy+8BRdhyjhiiioQ5Ie9x4fIQKe5x12viOzklFB\nPNT3/4Br9nEC3PdfU2l0NRkt7sShocwP6vKP+6Q/tigIj8JMwiF5bVRgRx7lh4YvrksqnYm04bKG\nIEikEgk0VWZ3fx+jv0dqcplYuojnB8iijCC6hIKC77uH44VoqTY6l4iIKUtDIyFZRLDCyO5WCtAD\nh82dDTK6RMxQCUWV/4u794yxLD3v/H4nn5tz5aququ7qrs5xAmc4Q0ocDkVSK0qkKMlhJVnBX9aA\nsV7YXhuwvVgD/mLINjZY2JVsQZJ3oSxTjBpyOJwcuid0jhVvVd1bN+d7T3z94dxbXV3TI9m7MCDp\nBS7qphPvqfO8z/P8Q7tVpVKpIskShw/NU9xcIRrSiEVTFEpVZEUDz+P6hx9w4exZNne2abY7xHST\nbqOCJrvUWj0UJPA8yrtbZJJhtjbXWT55Es+R6LXrNCoVJrJptjbz3Ft5wNETx9lezzMzt0Cj1WRh\ndo5sZhxNVkH0GU9lKezsMD8/y8Ducez4UZqtJtFYlEhE5/rNq6iKxOlTy3iuF0yUXZvtB/fp9GzO\nP/kMtWYXRYFBv0G30yBqSGTSaWrVCpVyEdexiIQNImGTW7dusbR0mEajwfKRI0xNTNColtgpbLG9\ntYll2UxOzOALlVg0jmqoPHhwH0mCequJpEiEDAPPc4nH4kxMTFCtVuh2u2hDE5RkLEm70wl0FETg\nBud7blC2DpnUqlVyY2NUazVW793HGrgkInEUSaFQ2GF8YoJWu4HrOEzlpsASHDt8BN/yGHT73Lp1\nm5m5OY4ePsSH126ytVVCkSUKOzucO3uBSrnG9s4Oqq4SS0TY3lhncmyM8xfO0G51cB0fMxyiXN7l\n/MXzXLt2jfn5RRzHQ5EkJOFjaAqmrtJq1Uhn0kzNHsJzXJqNDtF4iLv3bqFIBqqmYYQMvvSlr/Du\n5StcOHuRpcOLJEMaqxsbXLl/jy9+6XPoZjqoYKgK9+7cIxpP4Hd6uG6fSnGTl7//I378C1+h0myB\nrJKIR4hHwzTrVXKRELrTZ2s7jy98ZNtFsiwM38br1Zk9NEfLFty/t0ZEl5DCcfBVTp4+STaXZStf\nJDc+TmY8jWqESGdi1GslPv3cp7lx4x7haJZmqweyj1BcXnj+J/jud7/DzQe36Vtt1m9vYLUHdHsN\n3nn9XTKpDI1WnXMXTjOwBriOx+TYFIN2lQd3bmCEaGAMzwAAIABJREFUdW7evgPI9Hs9FOBnvvw1\nXNdGUmXC4RDC80D4JOJJSrUKphFCkoN7YqVcIhQKUS5V6HSbgfKjkJBRWFtfY2srz0cfXqbTaWOq\n8MwT53n+uaf5wt/7mb8DAfxW/p+MbnQfF+f4OIL4caXzx5VDH/49yEcebmvfc3mUFUoSSCq+CLJ3\nT4Dj+ii6QTKdJT2RJJ1JYYRN1lZW2Npcw+60MBUIGwaGroACfdcKAEeKieJJuMjIsrZHWxKBkzRC\nWGiSgCGvPYhLD6sOIy/vT+JcPy7w7R3fAUT3nuTpMJPWNAVHgG27KJJgIhNlbX2ddCqNopo897kX\naQ8Cz2tZCDxfQuLhOh7NMGVUVcVxHPp9C8dx9oL8XhVllG0HOxWsY58U7f4h7zu+/bSxEYJbiMe7\nkO3fn0dR8WIvcI/c30bLHqTFIau4Q6qXYOhaJ2QcAUY0wftvvI5qhJlcXKLSt5EUBeHZqENe+d5v\nM2QqBJm3wPfAHwxQPJdoSEX1BihOl4jiI2SZWNSgvbvO/ZuXyWZjxMIKG2v36fTazE6NU97doN2p\nEwqHGZ8aY3NrDTORpVre5blnLrK9vUoqHqXVaOAhoSdSRGNJtvPr9NpNUvEwqqZSbTeJJBKsrN0j\nm0tTbdR59733OLRwiInJMTRNojPo0u3U0VV4cPcGL//w2+Smx1HNOG3hk0hGadbLSL7HndUC0ViC\neqOOrhqcPX0KQ1X4/ve+y/LRQLpTUuDW7es8+5nnKBR3kRBUdwuEVAWn20PRFDY2N/CETTqdoNVq\nEA6FKO4UWJxfJB6LokgKzWaTXrfL5OQk6WSSeDxOKBRCVRXqjRpra/dRVQnLttA0jUw6Q7VSZWtr\nh1wmR7vdIRQymZiYYHx8HF3XURWVBw9WUBWF8ckJbMvCER5GyMT13IBW1enSajaZm5sjd2iWdr9H\nPJOi2++T38yzML+A57pEzAjlwibLy0t0Oi2E8LDsPkePHmF9Y5VXXnmdqakxfvKLL1IsbPPZz3yG\nyZk5UpkcV29do9/voekaiWSGMxee4M13r+CjMD2/wNWPPqJeq9OsVpF9D0X2KWxvUq03OHnqLPn8\nNtFEEsMIU2932diucOHMSXYLZdqdBj4+xd0q6UySX/vV/4Q//qNvMj6e5Xvf+TZX3n+DaMLko5u3\nOXLyHA/u3OPYiXPUOl367SoTE2niyQSpWIzf/93f4tqtDf63f/lbXL+/hR5JYoSjeC5IQqVfKeD2\ne/wvv/EbdOrbKF6XD6+8geTbrG7m2Vy7ho9DH4lTp45y+Y2XOH72PE9/6jmi4TCOZSNcQadZp12v\nUt7ZJaqq1Mu7mJrEO2+/QtdqISswOTVHqzYgmw7x7PPP8v4H7/M7v/1vmJtaJBaNc/3GDfr9Nutr\n6+Q31/j+979LLGzyf/3e7/K973yT1dX7SAiufXiVnd0yvb5Np9vF9Tz+6//mv6TeKCNci8mJLJLv\nEYkaFHd3iEYSzEzP0Gq2aDXqTE1Nkc9vsrtbIpPNBZx/X/DeBx/wYG2Ve2srbBdL/Pqv/zKff/Fz\n5MbSxGNRnnvh74AW+ts3ggz8Y8FoD6w0Qh3zia8fItEft8zjg/4jmxr+FSLwdpX26ZxLclAid1wH\ngYovZGxHkEmPMzU5gy+gUqpSLRbptttIBBaQhqkzsG1kTcGXBD6BUYosB8Ypki8CgRcpUF8LlMv3\nH/7HDTr+v4yDme0ocA6nNEiSF1QehMzc1DhX3/khO/kdTF1n4Hg892M/Qd9XQVHBcxHIwyD86Hke\ngQo9z0dVtT0XtlF5fT9A7OAkaz+afX/WLPY/9gLuyERmxOWW96oqj6OJPdqTfzhG2vGPouYfTg7F\nHkYh4GoLAZIs4/o+ZiRGaX2TdDLB+OJR6oOg9WEoHpLvI4Zgxke2MQzsquQR1RUkr8e9uze4+v7r\n1It5NlfvsLFdolTYwm/u4tlt8AMObLfVpFgpo0kyjt1DkSUOLSzhCylQfjPi5NdXOHH0MOurD8hl\nM5SrNTw0lFCMne08miJYmJuisLNFOBZhu1Ck3mySTqfZ2MxTqTa4+MSTxKJxhAiAkbF4nFgsTDqR\nYCydxAgr3Lp9j0RqAqHImLJPs7SD5zj0PQNFVcll0wx6Xax+B0V43L15nZChMjUxxu7uDs1mnZnp\nGRQ1aCE4I8c1z6PRqqPIEpIkEJKHpirUqjU0VSccCrOzvUW300XXdeLxgDWiqgqWZeG6Lo7jEjJ1\nzLCOYegsH1sO5F4HFuFQBN/zqNUazMxME6DT+yCJvespHouj6TqbW3mq1SqqYRAOhQIKm6YTjUY4\nfHiR3d0ikqqzk99CkRUOHz5CoVjkgw8/QEgSkXicS09e4uatO9RbTWKJBMlkEsu2GPT7pNIZpsbH\nWV15wPnz5/j+979POjdOLJmm0WlRrpQD4K0vyKYyRKIRTMMgmYyzuLDAq6+8TDwSJZ1OsVvaRZZl\nCsVdnnziKQ7NzbG2tkKtUsLQNM6cPUuzUqNarRJPRlldW8W2XM6dOcNuqUg8GuXq1Q9p1Rt8+vnn\nWDp8lMUjJ/BkjUGnSW5sjmg2y3g6SWF7E9kwuXvnDn/x53/GP/4f/kei8TRXb95iZnYaTZYRjoOu\nKHhGlEbf4fSFJ/jssxcI6zKzE5OMj+VAD4PVwXEGDHyVd997l4snl5HNONVOlV6vSX/QIRGLkkiE\nSER1jh1dAOGTSiV48tI5avUKjVadW7ducXTxCK5j016/xYNbH1HeLZDf3KRWLbN0bB4johExDRRU\nXM9FlSUKhR0kAbl0lvz2LrqmoesGrXY7qFrKCn3b5uTpk0gIkvEoETNwqXO8gHrrWg6VcplqpYyu\n68RiUSQkTp06xfVrN+l2euhmmBs3b/JgdY1YIs4//C/+IUcWl7h/9z6mYRKLxfjUZ1/42x/A37qx\n8VfuxAiYNHo+GgeD8uMoRX/dekcB7ZFtBc/2evEIH0kGVVOGKGIfRVFxPBvLsYnGooxNjhFPJHA8\nl0qpRKW4i2tZxBJRBB7CtZHF0CbUD+hKLqDqYWwffEkKNjVsG4z6tSMK1GP3/a8ZB0VRHjlGEaCg\ndSOMcHwk3+GjN16iUS3TaNQJxVJ89sWfpGn5IGvI+EiSgi8+vj8Hg+YoYGtDNT3PCyReR68P7ovn\neYFxyYHf7GBw/VhvWUhDcZqH1YCPC8E8TmRm6Ib2mM+CFggPJzkiEIWVpUB2NRQKE5JtDNnHyE3S\nFTqSkJFdG03Wh1oF+4B4kr8n5yMUE8tyCEXDqKZBJhVneeko0XAEOTbO2bNnCCs+/V6bhaPLlMtV\nxsemqVZLnDt9GlPX2FhfZyw7g+36eMiBm9LODtlEFEnykSWJZqPD3OIxJDNKImJgqBL3797EDJkk\nUynur60yOzfP2VNn2CnscuH8JcKhwOWs1++hKDK6ptFrt6iVK9jdNqlUnNzYJFubu2RSCSIa+N02\nvU6PSGoCT7jYVh9TBRmPiUySeEinVavgOTY723lcx2F+bh6nPyAcNtFlCceySSaTSEOjIcvuEomE\nadYbSB4YmkEoZNLtdgmFTHZ3i2SzWZrNGpZl0ev1MAyDTqdDq9VAHgIXe71+4EEeS6BpGu12l7Gx\nMX70o1dYXFwkEgkPKUCCZrNFIpHEsW0isRiKolCqVFBUlc2NDbKZDKFQiDt37pCIJ2hUaoxnc9y9\nexfbshifnGBscoLVjXW6loWPRqXRxDQjNNstovE49VpteJ0rdDstZEkQj8coFkvo4RAT0zOEIkH5\n2bZ6nD15nMLONiePHWVpcYFKpcA7b77JiWPL3LpxnaeefppWt0MoFuPc2TPcuHkj+L/VVA7PzRDW\nA7MeSVG5fecO7XaTwaDHseOn2dzKs7Kyyv2Vu5w4vsyXvvxTTEzOsbtbR9ETJDJZiuurHF4+RaHe\nIREymJzIUW22+Jf/4n9nYeEI8XQOSVXxPZd4RMeQPfAcTFWmVS7iWxbJaJiXv/stpidmsGzY2a0j\n6RHu3fiQN954i5MXP8XJk2d464cvMzF/nE7fwrFtfvTya/TaFuVCiXfeeQvH9qjUSnzrL77BW2++\nSd8acPLkaaKRCN/59je4/uF7/NIv/jxbhQJ/+Off4sc/93nGMxka9RqnTp4EPC5eeJqFQ4tEwxF6\nvS7FQoFB30L4AQZKEAhdea5Lz3aIJ+MsLC4wNTFOr9Wm3WximAa1Ro1apUwmmSWby1Aul0il0hiG\nSb1WxzQNdvIF1jY2uHP7NncfrPH8Z57lV3/lV4iEw2xsbmCaBmPZLKXdXT73pZ/6OxDArwcB/LGB\nalRKHvW2H1M23T/+qrLqJ73+2DpGD/nRLM33A4cwpIAJLssykhwA5ga2jaOoROMxxnI54pEo/W6H\nWqmEcF0SpoGp6uiqEgDVRFCW7QUScEEPXBnhzR8NYp80/qrJzCedl71l/QBYBeA6HioOdj1Ps16j\nXq+jmmGefu4F+kLFR0aVwfM/vm/+gXL06P39Ge2ovG5Z1l6vefTeHm3swHL7/x5sITw8lsf3zfcv\nd/Bc7ae97QX3g+cGL2AViEA/HALTEeH5KJrGoFrC7jXJHDpK0/LQJFCxcF0B0qMTzT2hGkD4GooA\nz/UwwmE030fYHmYoRKnZCfj5/Tbl3R3mDx9BkSVq5Rq1yi5TEzNEIyadbo/Dh49SKJZwfZ/p2Tk2\n799j0Gtz7NgSl698wJHDx0E12N6tsjA7GXh6231qtSqJVIqB7TC/uMD7l9/n5ImTDHpDtzHbQlc1\nBoPesAIQWCA6gx74EnbfwnUsJNchGw9TKhYwDZO+B4ah4dgDmpUCdr+D1W4xns1QKhaxBoFvgaGb\nGIaO77q4joMQPo1mndxYFiEITER6HQTgWh6ZVAbf84Y6Ax79fo9qtcLYWI5isYgQPrFYjE6nhet6\n+L5HMpUkEolQqVRJxBMMBtZwMiwFiPtYlNXVVUb1HUmWAjGWUAghYPHIYWzXIRqL0Wg0OHf2LMlE\ngps3bzIxMcHt27cZz2QImybHl4+xtraCGTZJpFKohs7zn3mev/z+j+j0egHATAq85wfWgJMnTjDo\n94lGI9y9c5fz589hmiFu3rpNOBJht1hkfCyLsC1ioRCT42PI+PQ6TarlEhEzRC6bwbYdHF+wePgI\n3W7gVa7rBj/4y5eYnZpgZiKLY/eJRBMMPInbd+7SbNfodDskExnu3L0PwLGTJ/jCF7/M6uoW6ew0\nlWqbbt9F0hVKmyugGUzMLaLJKmFdY3XtPlcuf8B/9d/9U6rNJpVyGafTYO3uDQobK8QjBiHdoFEq\nIOPyrW/+KZNTUyh6iFR2kr7t48sqH77zBk8+8RS56UXeefs9vH6ftquycPgwJ4+fIJnIEI8msG2H\niYlx7IEDssvi4UV0VcX3ZXa2S1y9eo1jR48wOZFmZnaCD69dY7dS4ed/7hfYXFtjajKLQBAOGUSj\nKXK5MVKpJAsLh0imMjQaTWzbZjCwiMfiRMMhLNtGSDA+McYXvvATKFKAH0EEAk+6KqPrGrFonF6v\nRyhk0uv1qFWbRCNRXn/9dVRdp9Fo0Gq1OHnqBF//+tdptwIf9p2dLcayaaYmx/A9m0999sW/AwH8\nEzLwEY929BweRTE/LjAfzOAOjr+qjzx67flBRggPy7CjUq8rJBRFRfgC3/aQJXWIcNfxRIBs9oSP\nqgXCE4oaZAOFwi6NVnCjMQyTcMgMQG3CQxY+siRQJIZgtMf3uz/pmA5+55M+f2SdsoIQDo4X8HRl\n4aBaVVbu36HWaGC78KnnP48Wz+C4Ahk/AP1Jj6LI9/eOA9/2j/8eo++MqGYjDvtIzW3/eT4YuB+C\n+h4/OTvIA//rKi+PzcjFQY56oKLnjeYmQwT5CGwYkwRr9+8ytXyapuWiywL8LppmMprPBNcLw5t4\nMEFR/KC3LyQfHw/DcVAlgWZoJDNjhEyNjVvXKJcKROJJOq06s1NTFAs7eJ5A11Ty+U3C4RjlWhlF\nkvB8l/u3b9Js1Mlks5SrFWZnD9HuDvB8gef00SSBYahUKlU2NvOcPHmGO7duE41GcV0HVVGQZYle\nt4OqQd/qM+i1CYXDbG5uEDINwnqIXqdDNCRj93voaqCdrmoG0VgcezDAtnqkYibCcbjy3ttIQDgc\nZquww9hYFjNsUtzZxbYGOJZFsVik3qhRrVbwvYAVIkmCaqVCOpkhFU8x6PcolYqPXDu2bZMbz4EQ\ntIY8cV03MAyT3WIh0KT3gjJ0NBpje3ubTqdLq9VifHyMdDpJNBqlUimztrbG/PxCoO0gyTieS3F3\nF1lRiIbD3Lhxg0a9QTgcpl6vMzs7y6HZaVZXHuC6NtOz09y6fYtz584xNTFBs94gkYhjWwOq5TKb\nm5uBd7llMegPWFpaYnt7B9u2qVYrpFJpbt6+RTKZoNPsENIUBp0WiUQMTdNJZ5KUS2Xym5vMzc6R\n38zj+T6tVptms86h2VkEHqYZxrZtQrpGt9ui1+/hSDqSatIfDDh/7gzpTJqt7SKVegsf+NrP/xK+\npJDf3mVqfpFMbozdUo0jx47SKOZRoiG6HsSjKSK6wj/757/BmXMX+Mov/CK1Zp3lo8foVXeQ7S6f\n+dRTKDL8xbe+yXahxLuX3+bTz3+a42fOEUml8YREu9fh7KVLrN+9ie/5nH/qOdLpLLevfcD88XP0\nB11++PIPuHnjNpqiUSwW0DSJqakZao0aldIuX/7SF/nOd1/i3v11nnn2syRTCUJhjf/pv/9vef/K\nNRLxBMePn0AWDors4/kOqXSSK5evcurUaYQM3V4XIXxmZ2cJmVqgueRDPBaj2+sTicXZ2S2RzSSJ\nhUKUC7uYpkEkHkWWQNcC3QVFkRlYfXqDwLnuj//4j6mWSjTabT66founnr7Ez/7s1yhXyuRyYzzx\n5JOsrq4QMnRMQ6deq/LcC/9+Wuh/I9zI9o9HepFC7N2893928Pn+m/be+0Ie8m4fX0o+GDD2fy7J\nMp7vP1JiHQGfhAyua6MiMPVAnc0n4JXrQwcuX/IYCJeB66JH40zGkniyTLvdpFapslt9gKkbxOMx\nxjI5fE3Gdl1cy0VIAT2LoSSs5/NIZ/yTjvvg8f11wx9qcmu6huQF5e5Q2MQ09WHAVbE9F80LKgwK\nXuCffWD7+1sb+4FjB/v3o/Ot64GOtOM4OI6zV2oX+9a5f3n5rzmeTwr8+8fBCdr+rP6Tx8hNLfjv\nFsJF2asCWQysLoqiYA8skvEoCmEGtoSq7AdTBu55o7UhS7hSYO2qawZCUekPBkhRHVkzMQyV3PQh\nipUySyfO8e7bP2J1fRvZF9y+cZN2c4yBM8DFRvg2xcIGiXQKezBgemqCZrvFkSNH2N7exkNHjcao\nVqs0nB7Lxw7T71uohk6r1SIajRKPR0nGo0gEbY5UIsLAsfB9l3g0ig+4kmC3VCI0ZRCPRbCcBpLv\nk89vBCAv4SK6bWwnMOqp7Tb46MoVyqUis9MzpLM5QpEY7X6PmKowPTWBY/vEkylyuRydfgfdMJAl\nk0p1h8FgQLPZZnJsGiEr2M5QgAl/yIEPJh2NRoNeJ+DnyrJMKpXiwYMVkskElUoNx3GwNBtNM0gk\nEihKj52dHdrtNpOT4wh8srkcsiyzvr4elNp1k55j4fs+tVotyL6GJjvJZBIhBK1Om7WNLqquEE/F\nA8vQRJK3XnuVn/iJL9GuN7h34zpjk5PMnDxOt9sNJn++4MqVj7CsAQ8erPDkk0+wtb3J3Xu3mRgf\no1IpkctM4Ls2G6vrnDlzho3tLYQsEQ5FyGQy5PN5uv0+qVSGwu4us9MzvPLDH3Dm/DmWl09x9Nhx\nBu0GrUagmkYcxiIRWs0Ofcvm/oMHlHabIEmkxyaRtcD57rOfexFHCKyezfKpk3SH2hEz2TReKM7i\n4SVuvPcazUaNr//c19it1/F8mUgswcVz53Hbs6yv3OfN965Qrnf4yS9/jc//2Gf56MaH6LEs8XQO\nVdJBC/H2229Tq1VACNrtLtPT06i6xolTp5Bkn+eefZY3X3uHXrvPyRNnuHv/Gq63xtZmnmZzlz/4\ng39LNpvlx378y3QGDgOrSyaT4T/+xV/i29/9S1Y3CnTaPaKhCM16EdM0ybfzCCH43ve/x8zMFJqu\nEIvF2MhvMTU9TjqbYXNzi363h/B8ms0Wg76LqRtUq1UMVSYej9PtdlEkj1atSt9xSSaT9AYWsVgM\nd+Dy4P4q2XSSPoJf/fVfZPnoMd577z3S2QyRWBQjFML3ZEwjgirp9Hr2X3lv+38z5L/+K///j/1l\n2P034v06148EbwLAl4QyRAmDL/ZnZz4C75F17n/s9ZV9gST2cFABUWmIVJYg0Cv3JTxXoKIi+zKK\n5+LLKp6s49gDXFnBEwLN7yOw8SUPJAUPA1cy8FBoWw4Dy8UwYywsHmXp2EnSmRyDXo+V+zdo1Qto\nvkUmGiEZCg1Vujwc18X3nOB4hMAXgYC/4GG/WEj+kI4GgV1nIGsq/Id2n0jKI97nkiRQJR9dN/Hc\nICOUhUyxsEu5XMZUdTzfCkBrkoKEwPfB8R7yvUe/z0gg5XFAtf28/OB3dvcCtyzLmKaJrusIIYZA\npOD9Ec8cRrr4j/a4908ORp/tL4mPti9LKiP71z0k/N5Z8PADNvijyHEx8u4GRWFYQie41kQgLIRp\nUCzuYCoCwwjRdRws10MW7oGKgrxve4AvUJBBKGABURNVURi0u3TbPSy3Tzwdx7NshGUzkZ1C+D6+\n45PNJHjqqSeZn5thejLL0uE5ji8vMT87xqc+dYHt7TyLc/M0ak0anS6J3Bi2BbFYjNlDiwQ+AdBt\nN/DcHseOzoPo0ulWqTd26Q9atHstFE1lLDeJ5/hoElw4fZa5hXlWt1dY2Vqh23ew3D6W26XRqIIs\nqDda+L5POGIi3D7ZTIrzFy+gxxI4isLi4SUuf3QLTY2AFEwCS8UCuqqAF6ghKppGNjuBNfDIJBMB\no8H2ScZTTGbTeJ5Du92m3+8TMsMMen2azSamZiLLcmAm4nn0ej1mp6fAF+wWC3vXlmEYJJNJPM9j\ndXUdzwVZEqRSKWZnZ3HcALRo6gbddgtNkcjlcpw5c45Go4UQgpmZGZLJJG13QGI8w8raCh+9/z7L\ni4ssLy5y+c03ObawwLEj8zRKOxiSRyoWIRWLcOjQHCdPHiWfz+P6Mr1eP7DwzKTo9nusrKxx595d\nDE3n2JFFqs0GG4Ui+Z0SzUYPMxrn7oM1JqZmWN/colKrYrsW2VyOntWnb7nMLx7nwxt3UGIpWrYg\nEjZoNRrUW01cx6Nab+MiUIRgfmqGSDSJYabo2C6mEcUWDp5m06w22S1VkVUJX4N6vU6tUmNudpHD\ni0uYqobwdWzbplBc57d/+19z9fotJqcX+PwXv4gRCeN4Ks8/9xkUVeatt9+j49iYiSRzk7P0PEE8\nm+X+6l10Q6LVb/HaKz9gY2ODY0dPsrx8kvHxcRrNKslEmlKphO30+OIXv8x/9g/+EeNjM3T6Axqt\nDmubBWotm/HMIX7hK18nFwvzwbtv4AwsJFnD9j1i0RRT02NEIgGOod3q4jhOYFgUTWLqIc6ePUul\nVkZWJVRZEDag3bdQNJ14MkEikUAWEtFIkkgshWoqRGIJYuE4d27e5Hd+73fIZMfpWw7PPvUkx5eO\n4nketVqNsbExfFcE9/sH99BNg2av/Qgb5t91/I0I4Aczpv03/f3l5MDGU+wLHkEZ1mMYnPetQ0j+\nQxTzQfDTvm08koUN1ysA23FAFvh4KJqM7VkIOQgKAhXXh5ChIvkukiJh8zD79DwPRQ20sW3bRlUk\nJDw812Jg9XA8l3AixtT8PLmZOWqtPqsbO9y8c5f8zja2PSCkK8FDk/FdB+G5ILyH5Wo/yM5930dW\nVQRyMImRgkmNO5RtDfbH2XeuH4qW4ItA0GZI0bIsB8uykCSB5Hu02+3gBjgsjfvC/VgVZMShHpXF\nDwbtx537g9QtRVGIRCIYhkG/36fdbjMYDBBCoKrqXq98dG73c7ZHxzjaj1EZfwSe83xnH+pdEExg\nAvlUGemhCM+w4qLsqygc7OOPJiyqHmSxhqqhyRLKMOuWVeUhc2F0TQs5mAiKwMDFdR1AICvguj7Z\nzDi1agu338Hudxh020QjRnANREMcP3Oc809cot3tsLKySjyaoF6uMOh0sbo9VlY3iESjuL6DkKBU\nqzM9u8DYxBSu79GotwKVr04fq2/TabQ5emiR3c1t+vUOysDF9EH0B4QReO0Gu5tr7Ba3aDZq1Gtl\n3EGf+blDCNejMwyiiVhgN1qv1pCVQGK31+thmxEmDi+RHJ9GMnT6/QFRM0RUU7GH14kyFM4Z2A62\nF0x6CutriH4XQ/IZDAbEk0lagwGJ8QnURApVM+n3BvS6/aH4kkw4bGLZgRKd4zgsLCyQy+XY2tpi\nYmKCUChErVomEY9imirgU2tUAx6+LFA0Fcd1KVdrZMZySKqCkODk6VOk01m2twqEQxHGcuNsbe2w\nsZEnEo4TNuJIQufUyfMcXlpmbWOT6dk5Or0ud+/fI5nNsXzqNNVmi1anzaGFebaLBY4cO8oLL7xA\nOp2msFPmlR++RrdjsXx0Gd8VhMM6pUoJxxfYliAeifPiiy8wf2SWrUKRr/7cz3Ls+DLLJ44jKTK9\ngcXyiZN4no/vQSqd5dPP/ziddo9UOsvly5eZmJjANHUSiQRHDy8FSorAbrlELJtGUlQURaPdbKOr\nKpFQmPFcBlkW4EhMxrNUCnn+7Nt/iojIyKaE7PWZyoXwBx2+9a1XSeQWOHzsHJNzM4QjGn27Tseq\n8mD9PgvzR1icWeLDd6+RDmVYWDrG7PQ4rWqeeETl2o3bHD58FLdfZ/XODV76zjd5+fvf4aOrl2l3\nG9iuxcWLFzlx5jSVapVDCwv4eOTSKeJRk4nxDCt3b7O+ucGlS5c4deoUL//oVd54+y12ikUcz2Uw\nGABgGAaHDh0in8+zUywQiUUDZbtBPxBw0kOuaTkrAAAgAElEQVToelCB9ARIfh9N9pmZHqNa2mZ6\nLIuBj2/1MM0knbbFn3/j2/z5N76F67pUqiWe/8wznD59mpdeeonizg6XLlzg+tVrKJJMo1Ynm87Q\nbrboNFv72DX/7uNvRA/89Y9W/8n+m/wjfcpR0GZ/MBiWP4df8YUA4YHnI3sesgBlyF2WRWDZKO89\nJBRJHn4OihQIboxENyQBSARBV+KhapoEnueiei6+pKL4Hv/0P/9Fnr50jg9v3iY5NolnWwFaXZHA\nD3rLMCrXeoFLDYGgiQf4koyvqoRCSaKJJPFkkkgsiqkHkqutep1auUy300EID0NTMXUFVRbIeMgE\n4ArPAyQ5KOUTIOtlOQBf7InL7FG1hsHY84aBXQbPwdA06jsr3H9wD134WJ7P4eNnmZo/QbvXQx1m\n7kEwHArkDCsV8hDUhwhsMyUIKEEMLbeH7wWKZ8ojWfJesBcCRZbRhgFbCdLfPQT7aIIAj04AHjcx\n2BOZ0ZThZ8E+PxziYYAf+lWPJGL31jV6HMBJAOiazevf+zaXnv0xGj0HVVXw7H6A+uUAiG3kSCdJ\n4LuYpobvWzhWD0NXqW3usL25w+FDk7QaBULugF6zxuyhGda216lVdzk0d4hisUQmnebP/vCPOHvq\nJLIkGMuNU6y0icWj5LfXaXc6XLj0DPcerBOLRbHdPklTp12vEdJ03njtNU4fX6bbbJFNJgJdeyFo\nNhuETBVVk3A9m16nidVtEzF1YmEThI9r2UxOjGOaIaLRBMXCLtncGJ1un2PHl6nVawysPqoeAUkn\nGk/Rs23ikRB2v02pWubw0jLtdo9qvcGx48dxXDfwGVc0kskozU6DSq1EJBGlsFPCGriEwzGsvoWq\nGoRDYQqFAq1mk0gkjGHoKJrMbrES/F95UG/UMc0QjUYDwzARwqXVamKYJtlsGlQlqOpIsLNTRNNM\nJmemqdUb7JZ20QyDV370Kvfv3aPb6ZHf2qJeq5FMJKnUaly/fpNSuUZxO1hW102EpFCtNZmYneP+\n6jrLJ05x8/ZtPE8QCke4fOV9KrUqmmYMkwOP2bl5Wo0W8/PzqLLKzk6RTntAoVrFluGrP/1VqqUK\nf/CHf4KvavzCf/gfcPvuPe7df0A6m2VmeoaPrl3HFzJbm3mOLJ1idX2Tbr+HbuhsbG4wnkvx/ofX\nQQiWjizy8g9+gEBBeC4XLl1ipVhncnoeSdIw9Cj9QY9avcbVK5fp1vPIssmPfeFF/s3v/RYPbl/l\nzOlz/O7/8fsMrB4L09OUCiVe/JmvMXbkCPGJLOMTk8RDMVwhmJw8jKKF0NQwtmVx7tQSkj/g1be+\nQ7dWJh2JsLWT53Off5H/81//DnFTpVIp8frrr1LY2SSdSTA/P8tTT11gc32VmYkUg16LsWyc9997\nB0Xy6TbraLLP7FSWVCJCqVTgxIljTE1NsFXYIr+dZ3FxEU3WSaczKMPK5uLiIuVSGd0wmJ6ZDFor\nzTahUCgQ0zFCNNp9JqYniGeyNAcOW9U6nqRSarT4vX/7h3znOz/i5q17NNstJAkunT/Pl778IuF4\nGM/xCIfDlEolKpUK1UqFWCTG9OQUV95/n+JOnmg0SqfT4Ys//bN/+3vgj6MA7X//4HNJEsgE0H8h\nvD2RNVVIqAwVsPZNbnzA30PDjfJyUEY0seF3ZBHYO/qeB8ILHIL8QP7U9wWKLIHdRpFlpsZypEMq\nnXqZ+akJ5qYmqZR2kSQJ1w58qH1ZRtU1XNcDAvCbLMvDwOHj+e5ewJHlIEOwHJvBwEdXVZLpNOnM\nGM1WnXa7Tae1PSzzqUQiEUxTx9Qje17pDDNKfA/Pd1EULQDbDScM++VCH5aV3YCT63tEYlEUTUcM\nLPAt7EEfVZGQ5SB7lGWCqc6+/vEn0bT2/4aj7wVl/I+D8/YH9NH395uajLLfUZa9f/9HnHPgERDd\nqE3ySYDAUSYID7P3gyj6x6HqATRNo9tp49sWiq/hjSwEeTTQ719W+IEqk+N4CA9CukF5d4fZeAxN\nlbh95yZPPnOOzsYKqiSjSBJzU9PcuXGVVqOOjE+n1ebiE5e4d/8On3rmGRqdDo5lMTk+xlg2R7vT\notdtUdnd5sknLrK2eptQNEQ2k+D1137IseNHiCZiOI5Nu9tC1/XApSwUotsbsFutISSIRqMk0yae\nkNgplkhEYxw+cpSNjQ0GlkckEiGbG6ff79NoNLh+/Rq9/gBZVpk0Q0hoWP0uvusEFQjPxzAMisXS\nnnhKPp8nkUgRDofRNI2dwhYCeLCeZ3FxhuUjxyns1Lhz4zrhsI6sSIxnM0Nbzhb9/gDd1BkMLLJj\nOdqtHtF4gnqzgaYbaK7HYDDAMHUarTayomOYESQ0zFCMXs9m+cgJ2r0uvU5/D4uhyjKHFxbo97sI\nIREyIxQKBeYX58l1c4yNNYhEwsiyzO3btwP+cKtFMpPmnSvvMzc3x3vvvYdjOUxNTaLrOrbtkEql\nOLa0TDqT4Nr1m5w8vky1HGNra4tGo8H4+Di+kLi3tk7XquEj2NzKMzkzzTOffo5vfPM7dJotLl28\nQHm3QDabZXpiGlkEFbbX33iVL/3kT9Pq1EnEwwH/X1O4/+A+Y7kxLp2/wOW3L5MvlLAHfdbWVvhP\nv/orFEt18oUdFheOohgmp44ucHJhkd/8n69QqZf49ve+xVtvvk5UDnHx+AX+0T/4x1y5dYNoPM3s\n3BKvXH6N02dPEg7FaBcryAJMJcpuscbE1AQ+MDGWYmvrAZbVJWoI1jodQqk0yajGn/7B7zOWyXL7\n/iq1VpuLF8+TzWapVqu88dqr1MtF3EGfTmWdeDyO1W0wO5Vj0O/TqJQ4cfoEljOgWa/TrJVIxKIs\nLcxz6ckneOml7/HS9/6Szzz348CwStTpMJbNksvlKJVK1GsVIqEw+fw2W1tbWJZF17JRFOj2Akrg\nm+99QDwe5+r1O3z0wYd4nkcmGWO3tIOmK/zaL/8yJ44ukd/OE4qGaTQ7CEWm2e0wOzuLEQmTGsti\nRMM88+lncZ0+iUQcVf33D79/IzLwN66u7e3EQfDT/rE/UCgSBGKngamDLElokhQ4hPEwgwpWBBJ+\nADWUhvxu4Q/5vmLvwZBR5NkWvuehKxKGKhPStaC8KsHv/c6/4p33PuDOjWsklAHbu2WaXYcHq6uE\nI2ESsSimoaNrKhICT4CiBMpuwgfPDUxMZOEHtCQpQL37vheU9qQgSxVCwvYEluui6wbxRJxkMomu\naXiuQ7fbpdVqU6nWQbiokoyuyGiyFHC28fA9H0WWgomH8INsWH7Iw5aH3tWKBKqiojpN7ty5Sa9Z\nx3Jd5o+eYfHYWToDC2XIT9/vMiZ4nGLaw/GxYDYChfFoFv24nvbBMcqq9wd2IQLXuf2Be7+c7mgf\nRoYvB9HzD/dxnwrbgevsIKjO931CqsvL//ef8LkvfgUplKBvDTB0Bdt2Hl5/owrBI8RAgef6OK4F\nrkskpmN4HjNT49y9f5dWp86xuRl2NtaQtECwxFBl7F6Xeq1Bu91memoS17XI5DKUK1V8dLq9VnDT\nq1WJhCKUy2VmpsYpbm8zmY5Rr5Wp12tcuHCeZrvB7Ow0Ozs71Cq1gM6nKEQjcaLRGKZuYpghdF0j\nEonstZQGloMrBH3LQjc0KtU6qXSGUChMJBKi2+2RSMTZ3t3GMA1S2RyDQR9/0GduPMe1a7cIReJM\nT01h2zYbGxtMTU3T63WRZZlEJMkbb7xFu93kueefobizQyQcxXFd2p0m3W4Xq9/D0DRKpTK+CIx+\nVC0wkKnWavi+RLPZZGBbAcsCiVgshm17dHt9dotlzFAECZlcbpy1lVV6gwG+79HpdlhcXKTf7Q2r\nfh6zs3N0uz0sy6JUKrFbKiAhoRsqtm2xuLjA/KF5otEIqqbRaDQpFMpYg+6wZz5NqVSm1WqRSmao\n1RpsbKyRSiWxrAGnT52kUCgSDkVJplMISbBweJFOu83LP3yFbqfL0RPLuJ7Hg5UtTpw4hWMN6HZa\nlHdLSDLcunmb5ZPLnD59hnfefZeJiSzPfupp3n7rbdqtBoO+x/zCPJIMK6trlMpVTFWhVqty8Ymn\n8RybVDJJt91GD6lMjOd465XXWbt7lY9u3uD9966wtLjEv/rN3+TLP/0VPvrwQ04sH+fD6++zuDTP\n7ZtX6XdqKJ7FvRtXCRsq585fYm1jm0g8Tq1RJZdJoyg+7779Jn6/z8yhWb713W+zvb1J/sEanYHN\nocOHmZ2d5emnn8IM6Rw9fJjpqUlajSaeazOZS+MLl6eefIJrV68TMsNMT83Q7XaJJmLgO4Q0BU2S\nyG/lOXv+HHOHDlEplVhf3wyYFGYIWZJp1OsYmk4mk2b5yBIrKytsbe8E+BzXQdF0JEVGAZ7/zPNU\nK1VSiSTf+LM/R9dVQqEw9WKJCxdO8tWv/hS6rKBKBJNQScYIh9na3sb1XDLZLEeWjlCrN1BUlY3N\nTXbLRbq9Lrqh8+Qzn/3bTyN789r6J+7E426msiRQRPA3eM2w3D0MAgiQht7MCJCG6bg0CvaAFAAA\nJDGSUR0tNzSecCxUSeB7LghBvVah3+uwsLiI4ytMT07w2kvf5OLTz9GybNqtNpNTU1x57z12trcx\ndB3XcVD00JD/7AegKHw8x8UbOo/5vsCXfFz8IUANJCEP5VYBScLzfBw3yBJlVUMPRQjHEoRjCaKR\nGL1ek16nRa8TUGoQLpqioGkmmqqhqSqI4Jwg/KAtMFSpkxUVSQRa8YrT4upHH9Cq1xAIpg8d5fjZ\nJ2h1e8E5kvf7aQ1/j32x9mNUtQNBM5g5fTIlbsQNH4m97K8WHLwm9gd0eLQHvp+eFqxXAcTHeuej\nyYKiqI8YnRysMBxEsUtuk6tvvoqZzBFOT6KZGp7TQ1OMvQlKYF8rD1ngw4vO9wiHQ/i+hyZLCBwi\nPriWxdETx7j8wVsoVo90PIrtuGTGMgz6XZKRMJqqslvYRVYkGo0qY2M5XNdj4PpMzczSaDbxvAC3\n0GxUWT5yjFQ8SbO6ja4pfPjRBxxbXqLZbLGxvommBN7ZqUQycK4THulUEllWsGwb27aQpIA7ncvl\nGFg2nU4HVwh6gwGmEaJarpJIxBG+g+PYZNM5zLBBsVBienYO13UQbh9TkSnWGtiWQyQaRZZlms0m\nrU6LkBlCVVXMcJTN/BbRWJilpUU6rSa+7aFpOv1Bn1KphKGpZNJpPN+hUq0SjkbwECiKTiyeZGA5\nRONxev0+umHiC9ANA90IEYsn6A9s1tfXcRwHTVXp9y10XUPVdNKZFLFYjGarSTaTQZIhn98iFosT\nj8dJpVI0mw0UWcVzfcbHJ0inM2zl85ihELlsjlq9RiIRJZfL0Ww20DQN0zQJmRE2N7dwnKBlo+oK\nM9PT9Ht98ps7SJLCZn6b7cIWsqTguoJ2t4ukSBiGweLhI0xOzSPJEoN+j8FgwPh4lqWlo2xt5blw\n6QK27aHqGv1um3QyxYeXP+LZZ5/l/oM1NjbXSSZiCB9qtUZACfU9/qO///ex+j0qhW3mpmaIhnUK\nO3lu37zF+1fewPV9XvjS3+Of/a//gnqzTqlRptttYBgqntfj9s1rnDtxlE51h9r2Jtubq+Q3N9HM\nEEeWj3Fn9Q6nTx/nzs1rbOfXEL7LzavXuHH7Fo1WHdmXeO6ZZ+kNLHxJJWJqPPfpZ3jpL7/L4sI8\nnusHVrqrD6jXqyTSKc5dusQ7V66QzY7T71uEohGSqSSNahl8h3gsgo/E+vYWF598guNLyywdW6Kw\nvc1WfovJ8RySkKiUyhyanWMsO8af/MmfYbsORsgcSkyrGKbJdr5IPBFHQuLNV18jHQkjHI92o0Ey\nGuVXf+2XsQY9aqUquVSaldV7bGzt4AMbGxt4nke9Xsf3fZrNBpcvX2F9fZWpqUl2y7s8WLnP13/h\nl/72B/DXr64+dicO0n723vd9wEOTHvpIjzIcHwlPDlDqPgIxrK9LjBS1JIZ+HMji4XZGalm+L+j2\nWqiygiz5Q6dlQTwZJxIOPGjHp+fRVJVXv/cNTpy/yKnzT/LUU08SjSbIZDLMTE1gDfo4rkckngRJ\nQlUe3tjVffabsqoglIAvLMkKsqQgCyVoBMgECGlZDnjpsoqQ5CHKXcGXFHRNJZ2MEo8OrRRlCcu2\naXeatFpdWq0mvU4HVQsCuTpUQ1M1ExAoqorwXDRNJ0yfm7eu09gtgSIxObvIqYvP0Ox0UWQ1mBQF\nJ2yPYidgT8981EcendODAXx/Bv643vX+9w86jI3GQXnUh9WER4O/oijYlrtHJfR9bw8tPzJfUVUV\nTdOAhxz2UYtjtJ3Ac915ZLuZiMJ3/+gPeO7zXySSm6LV6aApoGsmgaxsoBAXmMsMpWYVGR8Xq9/D\ndwNFPtfuofRtnMGAWrvKuXMnuP/R+yQiYWYX5lnbXEM3VAatFqFwhBvXb5LNZZiaHOPGtWuk01mU\nUJRu3yIaS7C+uU4kbKJIEr7n06g3OTSdpVzaBQSGYfLB+x9Qr9R54bMvICkSqqZihsz/h7o3DbLs\nPO/7fu/Zl7v3vnfPPgPMYAZDECAIkmJkMKQkUmKJspS4YqXKcfIlJVmSKVWkJLacyI4jO5WlUpWk\nUkocia6SGItaKa4gIFAESGCAAQaYvaf37fbd7z37ec/Jh3NnAEqfEuYDfar6S3d131t9us/zPs/z\n///+IARhFFGpl1E0gWXa4+61cB7s7R8UEyDLIopCDMvCNAyiMKTZPMQybYaDEQsLc6iKwc7OPlEa\nkUYRcehhVKq0j4+Zn5tHZhkLCwtsbm2hKgUOtd3r0xv16fTbOJaKqWj4w4DdrV1KjkOlVqff7RQH\napHjhz5hFOKUXAaDEYZhc9w8Rgio12u0Wi2EEPTHaGPDMEhTyenTp7Ftm4mJYnqAEFy//iZDb8RR\ns0kSx+TkBEHI9NTsGASj0Wwecerkae7evYdhGJw5c5atzU0URaFWq7Gzs0MSRSwtL2GYBkfNJmdO\nnyliR1ttTpw4jarpdI9bVBsVojBkNBji2CV6vQGqZrAwv8rR0RFzM9MYLkxMTRKECbubh1z54Iew\nLYskjtnaXGd2Zor5+TnCOOGP//iPePrpZxFK8X/Z6/bpd4f8+I//BC++8CJCFfzCL/ynXLv2OoOB\nBzImSSXPfvRpLMPgqStXuPH6m5TLDqfOnOYLv/e79PtNnv7Qh/mlX/01drf2abWOwJYcHG5z0D5A\neh5BMGR1psbt66+xu3EXQzfZ29tn8dRpkkyQq4K33nyNOzff4Tsvf6NYB/WHnD57jueff57d7W0m\naiVa/QFpquM6Kh9+9mmuX7+GbZjFgSQIGUU+t+8/4Kjb4qlnnuH++gaeF6EbJl7gI8lQ87SI1w0C\npmZnkJrKK6++ikxSnn76adI4YjQcsre7y2AwpFqtMjs7S7fd42tf+zrVyckiaz2XjDyf0cgDBW68\nc5vbt+7gDUaUDAPXdnj+48/z7z7/PAcHO+xsbZOnEtcwefvm20gUHqxv4LgOh4eHhGHIxsYGn/rU\npzh58hSh7zMcDdje2WZqapKf+ul//9/+HXj6yMf1vvG3KERmiLTo2WSOyHIUMcaqKgJyQfbI5kPB\nsH5oAVMKyIoiBEkiyUSOqhb4UKSCJlSkJshljpqCIVQUJFKkDLMUgxQShcwwSPMEA4u3brxDY2GW\nyclJbr7xXWwREnWPObt6goPjAZZlUXNr5EhKdg1v/LBWUREP36coYj1zQbFvpjhIFIcUCk0Z7xVE\nKSUKKZqikqUJuqoU1jchxoUGBnHxO1FUE6vs4FY0RJaTiqL4xGHIqH9MV6akmYJuWBi2RcnSyeII\nw9BIBk2MPEKTMbqekUQpw2GfJEtIFQWUhCRNcXT3veIt0zFBLi8ycOX3d9fv94kLIchkDkjU8e7n\n/djV9/vJ3y9kfJjTromisGqaVljaMolhmoV4UVFJMolAIROgGgZhmqCZRYgIKqRJgozBsVzStEuS\ngjdKsC2HNC2Ks6obyKxAxhbpauNOfbyO0HWzENUlNlGaYOYZei6RQmUYxsiwU3jnTYtoPAlQ1THQ\nRQiQKmmUoxKRCRU1G5IYDsPhkEF3C4sZZpaWeOnVV3gSgaKZ+JFK5CV0xWmqV6cwzHssXTjDrb1D\n7MYMMoqRaUy97NBuHnP18hW84YjXvvs9SqUKZ04t0B+EzM4sYqoaT5w/z8gb0OkdFDzw8WXbxaTo\naHebNE2pNeqMwhGO4yAjn6plEHsjVFXFVjR0RUF1HUZ5TNm1aEw1OGy1GYYptUYVx9XpdVpMTkxw\ncHSIotl0Bn2EJvDaPTSR4egqWRJSrk6ytf4Av92kYbv0jj3SaoV31u+zsrbK/PIqneYxh0dZsa4w\ndeq1SXojjyTTUVXJqN+jYpt0WsdoSBZmJhkOBmQyoV52sC2DLDbHf3cpg26HXq+HZlqcOX0a07Lo\n9frcv/eApaUlJmcmOe510G2LydkZ3nz7LRbm55ms1XjsyuPsNPeJlRxVUemHAbmqEueS+fl5vvfK\nq1x+7CIHu/sMBgNm5+e4d/8WKysrTC9MMTs9w8HRIZ1eF8dxqE66hEGAFEPskqA7OOZnfvpzdLtd\n3njjDeI4xDvcxHFsjDxgdrpwAOzu7vPch57jqy++RHvosbpymjyV7G5t8sZb1/l5zeDyBy9x5/Zd\n/o//81/hBwFxMiJOY1Kgopusbz5gfrJBkrX5kz/8SxzH4WDjBqdPrqLmPt2tm4z8gDSV1PVJ+prN\n1uYG/rDF4+fO8vU//zJ7xx0SYTGhu8wtLZN5Me5kwuHuPfZvvMnrb76BpttMVKb5xCc+QRAH+MMB\np06dJIhTSrU62BYyE/S8gCjTuLu+y7NPX+HoYIO1mVlOzi1y+/ZN3nz1Gltv36JcdunYJquzs/S3\njmjMz6OqNq6tsXFvnW48wiq5vPna60RRwN/9D3+e5RNrvPrKKyRhwv17D+h4HqNBj1yD06eX2djc\nZuj5+GFCqVQiSRJkGjE7UcOxDUxN8lOf+Qmmp2Zo9vYp1y2OOgmV6TpD4dMNPcw8xYt9sl5Od9Rl\nrr5I3gsJRcazj13i+KhQvbdaPbZ3j37g2vlDUcDJHnbY4wcpohj5jr82HkJ+36WM95bK37Apjbu5\nPEfKlEwINMGYtZwhUNENAzJJLCUaY562yPEjD8e1KJs26ahPpVzDS2KEXvhMK5UKJAlJFFKp1ZmY\nnmQ07BcWHkMQU9CfhBBkSYRi6OOxcYZ8+P7Gxfch4AMhHgnypMxQ8sKu9RAEIoRAFKm2oAikEEU8\nnxAIXUPmBSxEjDtOJcsxNUiSAj/pOC6GptOouuNULEGGgh/HRFHIjTffoFwukwQdbrzyIkszVeIo\no+RW0TSDJEzQFB0lTym7FZR0LJgTAn0Mm8lVFUvVx0K6966HnvtHtzmT5LkoOuGHYrVxF1+gNfNx\nR/yeIC0fuxBUwyg800GAbhhImeB7MYaqIcnHr/0w6rQAxeRq8bcQxx66yKjoNvfuvMXCqQVUVQND\nJ5EpWQ66bqIoCkEQYBgapqERhiGK0B9NS+K06MwDmZBmksFoRCkr/Hx6Md9BCJUslehCwR2P5NK0\nWJcINUUzNXTFRBcGIi2R+CEzUxPUSjpqHqOrCosLszxYv80nP/UZjsMKx43Pglpmcg4GvU3eeP3f\nYKkm3nCEoWmEccxoMGQ06Bf7RqEwNzdHHMe0Wi2SJGLtxBK2aRCFPnFSwHR838d1i515uVwmCIqC\nvrKyglAL20un08Fx3MLPOjPHcDhAUU0MIQjDEMtyUMi4c+s2uu0wdPqo1QoA09PTHOzvEgQhpqtz\n/949nrxyBduyin3+wgLXr19ndnYW13UplUr0BwMuXLjAiy//JZZjk2fFOFJDMD09DWlCmsYMBgPi\nVBa2H10l8Hwma3VqjSrN1jFGpDE1PV0cgMf6Btd1afcHGIaGZRkYkUWtVqNarXPUbFKrVbl48SLd\nbpej/SMUU2d6dgbLMCmVXJrNJmtra4RhTMlxqZaq3Lp1i9XVVbJcsrK0iKLA6uoq/X6fer2OYVhs\nb2+zMD/LqVMnGA6HbG1tEkQhT1y6jO/7GIZBlubs7O1iGD79fp+7d+9SdktMNia4c+cOX/3Kn/MT\nP/FjWJaBY9k8+eST3Lu7QZ7D8x/+KL/3r/4v/vFv/lcsLq2Qhz7IFKnmXLlyhfX1dd595x0cx3k0\nnUqlJFeKJuDr3/wGd+7c48aNG/i+z8LCIr/8y/+QP/+zP6HbGz5yl1Qsja0H9xiNRvzoxz/BnVu3\nube+i+nYnDy1SrlUZTQa8fUXv8GT5y/Q7TS5t7vFyuoqv/iLv8Q/++1/wUBL2d3bo1ZyuXz5MorM\n+dZ3X8MLQ3xvhGVZrCwt4w9DRkMfy7IxbQNT1bh65SKry/O0z5wAYGN/m6OWUgh8hz55LpisN+iO\neghTp33cYmJqBpmqfOlLf0ouUy5dusTS/AI3b97kL772Vfr9Pj/3cz+LZmqkMufO/R2qtRJpKvGD\nhJJroeiCjJwzZ5/A8yO6/S6W5RAEHqOhR7t1myiKmJyc5M6dO6yduUDZLSHUgsJYb9RwbQtd1Xj5\npRf56Z/5HN5wwF9+++X/T+Xy/dcPRQFXRQ4PQSwAvP+h/7CIjQu2eG+cnmRFwciRCKF+3z5WRUWQ\njffi41xqKDjkaWG4ylKJqmsoCqThiCTySQyBjEJ0ATL20TWNJE0IfZ9GvYwqYgK/S2OqhutU2d7c\n4cH6JvWVUyQyfnTuSPMMS9fJ0hQh3hOO5e8r5DAWgWUFk1lVFHKRoSvqeBhR2LWycXRmmuSgFjvb\nNMuJ06TIHjd0MikQukEaJ8g4QVc18jxj4PlomlJ8XiYcd9o4bsF5bh8dsrS0xGHziP/iN36DT//o\nl9ndHWIYGmkc0221SZMIGaUgMsI0wdK0AjQiBIppkiQJaZKh6BpSJt+36vjr+/B0DMsQqgJ5UaQz\nkaMKBZkV9zxJ/ia4J46LLlPXdZIkQjdo5hQAACAASURBVFEgTwrfcyYUMinJpUQbr7F1CaamIFQV\nNVdQ9AxVerhGTNg7wFBX0CyXJM0hV1DVAiYj8pxGzUDXi+JklFx0Xafd7SGEQFMNvCQATSdNY7xg\nhBBgCgVdKOSZxDaK30kcBORBCGPRoKqb5EmATFXQdBAKaZQgk4iD/gFlx2R+cZbAEeRpQLkxy0sP\nKrhLHyr+ntM+Eg29tgr2f8T84Z9ydHCLmblFHNeiMVFjeWmJ+/fuYds2cRJSKpcYDoekaVrEG0Yh\ni4sLfOflDRrVKlmW4bruI91AqVRC1/WCDx0XQSHT09Ps7OzguiWSJKJcdqnWJrm7/gBd14migIl6\nlUqlguW4RL5PpCmUHJvhoMfKygpbmzvMzM0ThiGb6w+4evVJDF0nDEOmp6dZX18nTzOq1So5sLmz\nzcTEBJPTU4yGHqVSiU67zamTKyRRQKfVZmJqkt39QzxviGVZVCoVdnZ2ULT3nAnD4ZB6vV6I5ra3\ncd0yQgju3bvHysoSlUoF0zRpNpv0ej2kLJTrpVIJVVXZPdhHJik7OztoQqHT6QDQvNXiygeuMhj2\nqZTLkGfIJMaZqOJYBrqhMj09g+cFWJaFa9mYpokioHl8hKqqbG1uMzs3z8qJk2xsbHC4d8j5xx4j\nzwVRFNFptVEoduBPPPEEG5vrvPrd73D+sfM82Fjn8UtPsLy4xMHeHh//2I/w7Ve/y//2v/+v/M//\nw/9EvrzE5z77U/zev/5dnr50kUuXLqGrGnfu3EEIBdOyiGK/+J+UGS+88AJ7ewdkGdiWw/PPP89w\n6HF02KXkNvC9PsNOk9QfUXdtJms10ljSmJhGNQxmZ2epOBZnTp/kwx/5OF/91jf5/C//MvNz0/z+\nH36RXBYul3/23/82X/jCF2i1Wpw7eYK///f/Y7755a/yX//4Z5iYm0PNU9ZOrPC9V1/D6++yvbXB\nhQsnSOIAP4gfjb2LQ8YCs2uLqGnO/Xv3CIc+Fy9dpjPsM6nOYhkmQ2+EF0QcNw/Z2d0iy1L+9Et/\nxL/3sz/HJ3/sU1QqNW7evMn6+j2qjTof+MCTtDpt7t3dwAtjQKHeaBCFAY1qFUO3CYMYT/eQHkW+\nQwhBkOG6NcgFczPLDAaDol7Uati2Tf+4zWSjzsHeDrapc//eHT7+Ix/ltdde+39bKv/G9UNSwLWx\nJexhF/3XeNv5eH899lV/n/hJjIv0w86WYmf6fspNJt63a2W81yTF1DSyOELGAcGwj12ykZFHEsU4\nhsAyVIZRSOh5kEGcDFlaqLLXi1henGcw9HBsjZJrgiLJ4uK1HlqS/DhCJBJd1wt0aZYVJ4j3XUII\nNKEgNLXwO2fy+8bJhXBNJc/GY+tE4Gfh+07SGUkiMTWVJElQKVYNcZYgTJ3QL8IcZDjCHw6KcbRR\nIC1XF+fIs5Sp6Vleeumv+KVf+hX+8Au/Q2d/d6zSl+ikEAegCZIwQegWmqYVU4Y0JZcZMo3J8hRd\n1R7dh4e6gux99zIXElUphHMSSS7HBxlRQFVUVX0UP/r+iFEFQZZKJAJNGY/uyYusdLLC6ja2XpGl\naHlGnqRYuo5IFZLAx3UEFROEHKCmEao0EAgyAbmMkA+nB0IhDJPx60Lo+zi6CarCsN9D1TXyDHQB\nYTRCISXxhxiWiaJIkDmGyCjZKpFfeMPTLCfzQyytUKWLJEYzJE7JgUwltiI6R3vc6u/jmjrtdI6W\n/Rnckl1YAttvU9M6RIFk4F5Er84xXPzbdPb/F+ZUCMOQNIqZnphgf2eHxcVFLMukXq/RbxdKc9cp\no2sKR0eHLC8v0+/3mZmfo9/vU6vV2N3dxbZtkqQYH2a+j2VZj0hSlUqBDdVNo6Ch2eY49WvEYbOF\nECqhH+A4FjIKMSoufn9I+7BJlKQ8/cxzfODKk6yv32dpcYHhcEij0UDXdYQQhFFAkqYEQUAQR5w9\ne5aDo2KHqKoqSRyjaRrDfkgYhsgcymX3URpZo9HAHwwZjQbIJKYbBkUYTKeDpmnUajV6vQErJ089\n+pzv+wAYls78WB3fbrdRlEKpvDS/wOa99XEnbeC6brHaUgRJECDjGFPTGPUH2KZJv9NHxgnVah2B\nxuFhEyimQXdu3iQOPbr9IWdPnaY5ecy1197ANG3u37lPGMTcvn2Xo4M91tbWmJ+b4/j4mBOrq4Rh\niKYa3L59H8M0kVnO7du3uXz5SS4+cYmN7S3+83/0G/zK53+VX/2H/4B/+l/+Jjs7e/zIpz7Bzbeu\n4Xkex8fHnDlzho2NjYJCBvQGfb74xS9yeNQC4NyZC3zkIx8pJk+KQqvdpdMbMux1sTWVw50DcglC\nFezs7lKqNRj4HgeHO1RKOlub9/jSn/wxb3z3GqdPneRjH/sYf/YHf8z9rQ1Mx+Ro/4Bo6HFhcZmj\nzR3+3s//PXRN49y9++weHqEYKr/5T/4RM/OTHDd3sVWT48NDTp8+zSgfYVoutu0SJSm93oCaoUEY\nsTg7Q0fv8e7NG0ytLIKh4Ps+U5UJ8qzDUfsATdcpOWUWFhZ4+eWXCcOY02fOcHh4SKlUYn5+nsOj\nI1qtFqmMKZcd8lzSabc5e/I8K0vL2I5Kq90kTirYpeJ/5cqlJ7h27XX84ZBR4FOv1zG1nMQP2d3c\n4MSpk/R6RaTrpO6yuLhM86CJbbnMTE3/4LXzh0HE9vXvvPOP0yQhi1PyVJLKDJkV1Ko8z4mThDhJ\nSJOEOI7GD/mia0jSeIznTMdktowkSQjiiERKEpkSJRG+5xGEHjKVpHGRIez3h4SDFjI4omSn2FqO\nN+oyHAWYWs5g2EHNc0QS4xoGZctFph18LyRKc3bv3+F4b5+nPvQx9NIkqe+T+AGkxYg7S+JC+J2P\nudhjG5sqQFUK2ImS5+QkCIp9qTn2ouZpUdQM1cA2tCLJTFGwNJWqaaIkCeFggKWoGCJFyABV+tha\nipp5uEaGmeWYucRrHlJSc5ZmJrCEwNV1hJaTy5QklWSKhhAaR/u7dA6PaO/ukgQJrltn9dRjDPoe\nC9MzmLpVEMSSuMCrjulwpqGPrWjFhEQRxchNybP3feRjJGvxurlMEXlhoyPL3ivK5OM9f/E1a/yz\nbbNYe6hqwSbXVGUc7Sp5SFhTkAgZY6oZhgYkHSLf4/KVi9y59y6mqTLq95ksWShBgOK36e/cJe3u\n0jAhjYJC7S90VFVHQX00uUnjGFPRsDQdgeDVr32RanWCqx98liQIiIIuSdwn8/uYWUg8OEBnSDQ8\ngqiLo4UQ9sn8FnruoYsB/qhQpidRzKRbo16f5bj0HOHEs+SKjiYHNMQ24eAAoaqYtkF7+zq55qC5\nU9iLTyGylJVGzu72NhXXwRsOUYSk125Rsi021jdZWVkljkL6/QFZKjFti+tvv41t21QqFQzDQMpi\nHF0qldjZ2WFiYgKAhYUF4jhEUQRJEtPtHmOYBUZYUwXTM3Moqk6n00YXMOi2SeMYXShoioKU0Gg0\n+PM/+zKnT58pJkpZxtraGkEQMBoVe/YsTRl6Q3Rdp1Ev8KJ5VgB+wiAkDiLiOEARCrqhE0Ux9cYk\niqaThiGHe/vIOGFqeopGY4JKpUwQhpTLZebmCj/27Owc9x9s0modkyQpruuys7eLoBDSDYdDWq0W\ncRwTBAH1coW1lRW6vS4rq6s41TJ3793nEz/6cd588zpRGHLyxAk8z0OgsLiwSK87oNfvUalUabWO\nCcOAmZlpzpw+XTy/wpipxgSXL15CCIVOt8/UxDR7u7tE46/nWc5w0OPq1asMhkMebGxw6tQZKrUq\n7966zebOMefPn+XWzZukaYJtGHQOD/ixH/koE7Uqv/lbv8Xd3T28SPLBJy8RhxEXLlwgDkKaR0cE\nYYzjmPzF175BnuVcOH+ez//yr7C9vck3vv5VqpUSmia4eesdFuanOTjco1Kt88JL36bbH1GtNpic\nmOK7r3yPW+/coN/tksmMKJJcOH+B53/kI5w+dRrdKeGnElczQBbro7XzZ9jY3KDiuJQcmySKEabJ\ntevXOHXxEj/52Z/kwYNbvHntJU6tLTA/PUeeSNAyNENjZnGGezdvU6uVSBMPEY4oqXBpbo3Hz51n\ne3cXXTcZtbtsb2wwuziDgs7U9CxHR4e4pRK1WoX9g102th+AUNne2UVVizXpzu4ucZxgWjajkc/V\nq5d5+pmLxMmI0XAAeUJ/0MaPQoaDPhubD7Aci1zkNCaqxEnIUx+4zHSjhqaAogoerG/y6c9+lubm\nPqdOnOQvvvIVTqyd5Mc//WlOnLvwb7+IjbQ4ET7qmYV4D7yiiPd1rgJB9qhLf9jpCiUvuNfj78nT\nhCRLi6QwFMglWSJR1Bw1z5BpimuZRFpRU7VckGUJcVrEXZqqWYzO45ww8IiCsPDEIvFGQ8AhCSM0\nxyKWCQd7e5xfPk+iCmzbRNPGoR+aSi4KOIySv6egFuI9fGkuctK0AH2g5OM9cUFze6jqTrwAz/OL\n0Wwck6ZJ0YWkMY7jMDlZwzA1An+INwgLBXwUoAmreDhmMapQ8Uf9MSNdQFLszC3HJVMNGO8It/d2\nC0KbCnES0JioYpRhd3ebUrWCZRloajHaF4oAVNI8I88FUr4H51cfqhbGHn1VVZBJsS4Rqv5IhFcg\nZkTRTQsx3t0X3viCtpeRpxKytBCICes9ZKpSpKM9VJczLjIih5JjEcUafhyxub3FM89+iPu3btDt\ndllYXkKLIhQZMti5TSZjJsycnBLCVUkzDWRWCOPGE5Iky5FxjJQ+huVglIqoyjxOkVlSHCRkjMgS\npNQgj0jjrEgD03V0xSaUPq5j4A0G+F6AZZXICUmTLl3rAi31CrliQpZQ5QBHD/nyV75Kv9PhzJkT\nTE01EJbNndf/iPlTH2Lq5IcZ1Z6lqe1Tcr6CZaoMR31OrK0w7A+wDJODgz1OnFhl/f4DFhYW8EaD\nsQJfpVQqPdp993o9bNsmDENs2+b4+IhqtT4enxd8/iJ6MSSni2EYBfTC8yiXK5w5c4YHd+9g2TZn\nTp+m3epy/a0bXLn6JLVag5UTaywuLXD7zq0iv9vz6PZ6WJZVuCZ8D4Dj4yNm5qYZDAYMe310XWdl\ncZH1e+v4flhQFRWFKIpQtIB6vcHBrs/kzCxJ4DMYeiR5xnDUxzZNeoMh/nia4JQSLNumXp8gjkPa\n3Q5nzpwhjlL6YxveyZMnizwA08Q0TdrHLeZnZukNh/hpwl6zybU33uLM6bPs7++jqirLy8u88847\nPHhwH1VV0fXie3Vdw7JM+v0+21tbVCoV8jzH933evXWLheUVgijm4LBJqVKm3esVPAfD4Kmnn6E3\n6HPm3HkUTScJRlQrDqdPnihGw8Nh8T51m3apxMryPMftY06fPsG/+Of/lH/wq7/OxoO7PFiYottp\nc/bsWY6Pj4vVkFE89h3HYWlhkTiOWV9fR1cFH/vIh1lZWeZofx9DzShbGodxwI3bNznodAhHQzYe\n3GPY69NuNXnu2Q/S6fUouy4nTyyjKZCkEWkes91sQ6WCF3ZYWpwjGECn1320qnAMnU7rmF/8/Od5\ncP8+iTck9X1ah0fYpkUWS0b9Ab1+C0XXWF5Zw7IsgiCgeZAwNTvF7OQkpqaysblJbW6aRqPB7Qcb\nOJrFzPwM/qiPMl7PTk5OkySSVmeIYRhM16dJ44QgCHjhhRe4fOUqS0tLjEbFekFmCrppkCs5UTqi\nO2hTq9Wo1GukagIywywpKKqk7FjsH+ziOA43b98mi1N836c6UWdheZ40jdFFzkvf+hq2IfjKn/8R\nX/qjhL/1kz/9A5XOH4oCbmhjctp4ZCrJi3EokD4cowuBqqgooqBy5SJH0/RHRfvh+BwK25Vj2IX6\nXIKhmWPCWoySSXJS0iBBFSq90QBbD1EEuKUqXpRh5TqWpjJIU6rVKoauFWEb5MSpS5waZIaFqqvk\nekSctvH9A4Igx7ZtkAVbO8uKyAyhKghVIx8XcZFD9td24qqqQFYUriQp4CTJuCtwdRPNMCg5Drnr\noGkKuqFiGSZ5Ltnb3+ao2UNRwdK1Qg1fqyAyhVKpVFjJ4oCKbTIYeNTqU/jDiCSTxEmOXTEIZYTj\nFD87UxIMTSElIAh76G4DNzPo9JvofYXJySlQNGKZgaqQpsV6QNPfu6dybAUT2TiljMJCBwpZljy6\nZ4L3Qlf0scXtoSXsvQNaYbPT8/dsalGSoqrjCFahkGeQCkCooGQEUUQsNTRLZf/wkJIjOHXqFNev\nvUWSprSP7qBlAYvTCqZmc7z7Nu7sGTS9RqZUiJO42NWrKkGcjN+bjkglkUzJdR3PCxB5wbu3TZ1B\n20fTJWGUUbIMRsM+llWIV8gkQike3lkmcB0HQ1MZphmjxicJ1HkAMm8fO9xEK5V56ZVr+EHExctP\noakqL738KuVKhVMnz1JSPXr3X6R64jkO0nms2idR7/9rDvb2ee7ZD2GZOlOTDa5cfpwkDrl69QrD\n4RDIaNRr9Ps9ms0mhmFwfHxMpVKhXC6PWfgCIcxH+pMkkQwGA0ajEXmeF6Kr8ZrDNHU6/R6uqTM5\nOYkfBhwcNtnd3aVSKxK+jppNJiYmaLVauK7L5tYW5y9cGOdzl+l2u+MpQML09DTHx8dFpne7yfLS\nKtvb28zMzHBwuIvr2sRxTLlcJoyLwhtFxURNZhm5IjhsHjE5OUkcBcRxjGWUqVbrdLp9hl5RzKen\nJ9nc3qLd6j5aG4RhRBRFlFy3UGzHMb1ul5m5WW5vrNMfjVhdXSWJc5rHXTTNoHl0jKarWJbBhQvn\n2NnZoV6fYjTsU6tX6HQ6dHttZqfneOqpp1hdW+O/+5f/kubxkKnNLT792c9y685tfN9neWmVe3fv\nEgQFGa7fH/Lmm28WHnRvwNTMNHEcsbOzRb68xmPnHicKQ+I05aVX/4rpySq6ofKJjz/Ghy89zqu3\nbvL7f/BvOHVihdXVVS5dusT6+voYzqPw2IXHuPjY+SITQRNcvXoV13VAZKiaoH6vzI03X+Pm/XXW\nd1ucOnOacNhDLRk88cRZ6u5lFmamyTSNexubvHPjGmdPn0FX6xhZzuWlNR440NFCBiKmphkEiWTU\n6rI6NcPnPvc5fu3X/zP+8oVvMVNtcLS/xfHBPokfUrJcapU6zb1jltfmUBWHQX+E1/fZ3zvmxz7x\nKTZ3NmlFQyZqVQ68DsgKwnRA0TBti4prkYmYOE2QFJoZXbPQlIzRKOLe7QMmp0yEEMzPz+M4TtEY\nSYmQEkVXeOfmbRoTFbb395ibrrO+fp8kFtQmJxmNRpxYO0WlXGZrawtVb2BYZbr9Al0cxgmtjQ2S\nIERVMpJgBNInGHZZXJzn9vW7P3Dt/KEo4HFaWKYSWSRblVyXNCuSqdRcIUWiqAoyH5PNRMEDzwXI\npICWkBWiNkVREKQIGaEKHV0vrCO6rhPFBWXJMXRIPFo9j2q5xKjXp2KXMFSw1Ix+OGDouWiqIE58\nZhfm6fZ9/M4IqdoAKCJgen6V6699B+l7OI5DHPkoZPieh2FYCEWFXCBySOP3AkUUVSGnYLbHOYX6\nN00ZDodIJKZlkaU5ZdtlemKWctVACsi1sT0ry0nDiDgtok2XJhqkTpk8L8AbURSQypAk6oAqsfKY\nhuviewPKhkBlQBRLTEODJMWVKWEYo1U0rKqDTBUyS8HPEmIEWSgwFJelmkV3MORo95BqtYxbckiC\nCIFAKAYmBQzHCyJ0yybNcmSSYmgqIkmRWRFOInLlPU+2EGhArpgIAYbQScY7aFPXkVmxW08RxCJH\nVzVkEmGbZmEVkxKpaESpQKQpZVUhH/YxXRc9DcnymCwP6B7tUTZVktjDVjMSGVEiLcRaUYyrqmi5\nxE8AM0PXxgfFJMRWIZchMpY4hkOm2ghDI0g9Bs0j/L6HWhVYuY9Ii3tkljRyWycOQ0putXgoZxLf\nT6g26ijEUJqkqXycXGiQRUSH32XjnWsctTtIRePxx58oVLXtJhsbD3j8iUuYps2tm7cwVJUPXH4c\n/8HXcdc+TmjMEy38HaY7PodHbSYnJwmGQy5dukS32300qpZS0mp3qFRrLCwsEIYhURThui6qWhSi\nMAxx3dJYwT0m9uU5MzNzBEGA5/eRac5g5CHTDNctKIGlShnP87h+/TpnT58hTVMmpqcKMZiU1Go1\n5ubmuH9vneFggG6oHLeOqFbqNI8OGA4Lf64mFA73Dwg8n/29Pc6fP4+UksPDJqpijAMnMsI4Rksz\nTMOg0+1SrriYmoHwRgyHHrVaDVM4JGnEcavDYDBANUz8IMAtlVhcWKbZbmEYBoOjQwaDAUtLT9Lv\n93FFzu7ePvNzCzQ7HarVGlmu4FQnmGnUeO07r3Ly5BL1RoVrb1xnZrHG3fWbdA9DLN2iNxywvLrC\nwcEeEsnqiRVGnsf65gYXH79Eq33MKPS4c/dtNE1haWGRza196hM13IrLWzff5vSJ09y9dY+jw2Om\nGzZJKCk7FU6dPMlXv/ESz37wKQQJJ06c4Ynzlzk43KPZ6nL93bfwkiF/+3M/w6uvvsq99S2O2l9k\nYXYBVbeIgwDdVJCiaJYO9vfGtqmiM/YHXfb3tjlqtrhx8z7z8zN85sf/Fr/267/GF37ndwg7Pc6f\nO0Gn2eT+7iaWU2VxagE/DLj2xluUSiUuPnEFNRnw2Y98jj/9sz+GfpOJksWHf+bnePEb3+TMqbNo\nmsFwFKCpBh/92Md46/ZrqEmIqUAwGFFyTMyVSTSpMYxGLC0vYKglfM/j/oMtLDK2u3ts722Tqz4z\nWcqDOxuEowRfD9CimLmpSYSU3N5roholSrU6b757i0a1RtUt0xr0mJuf5rmPP8/Q83n99dcR+djG\nmyaMhglvvLVBo26jyAgZx5CX2Hlwl+WZeVoHO3gDh9b+LpGSUrZWGPUHxHGGIlKee+IiG1ttJp1J\nNv23WVtbww8iTNPks5/5yR+4dv5QFPCHqV+5ItAtswCfaFphBZKymIK/T9yWZRJkIVx/CO5IxiPU\nLMsQUpLJAMNSi1jMHPxghJIlCEMjjgISb0iepYRBhGObpHFCGidkSYxjGYg8xXEsTNuh2WwRJRma\nVviNpUyxNac4POg6R0dHWJaFpoUMB4ViWc+LPZ2iaYVCnvfCOwYDnyzL8IMRefaQkS5oTE5imOPk\nrVxBxukYRpGDIkGTJGlQIFM1DT/0UDKDznBI1bKJ/BADhWTokWcxlmnQP2pRrlYoGyZpGKLqGkhJ\nQx+Sxiq5ahBFfRS9jBd0EMIi11UyNJRcZ397m5mlMl4Mo9THNAwc22R/b5twaBedqdAoVaqsv3ub\n1bWTVC27SN1KEixFL4RdqoYqI8hSVKFCnpJn2SMesE9GGkXkaU6ujovneGKSGVahVkcgwxhdUUlT\nia0bxCloqgqk5EmCyBJMIcn9PkLLEXJEyRREXpcsLXahri7wlBAZF4p2R7fJIhiFOdhlMi9EN00S\nWXjzkzhDV1VsyyZMUkxNUis7JIFPp31EEkTY0w2kCkmY4jgmg3a3SJ3qDJB2ThYXuFrHMUijBEFK\n33LJTQ2RdBhufYULZy+wNPXv0Or20C2L7736OgLo9wdc/cAHuHPvLqPBgJXVE3zw6lW8QYftjRtM\nNsoEpYuY1TnMZz6PMvomy/WI//v3/4DnP/VJoijCsizyPMdxHAb9Prqmsb29zfnz5xkOiyCHOI7p\ndrsMBgM0reDtj0ajRwI209RpNg9pHh9SrdSZm5llY3OL+UWdwQBc12WiWqHqlB4lgkkpOXv2LL7v\n884774BQqdZr1Op1Rt6gAJ0cH6OqKo7jPJq+lEolnnjiCXZ397l79y6PP/44CwsL9Ps9SqXSI2V9\ntVpFCIFj2xwfFR1+Gic0anVkkpIjsR2nUMm7DgeHTSqVyqORua6o7O3tkWZFAIXneQVdTS+gQE7J\nxY9CDg8PMUyTJAgYDQSmVUyLojhlZmYGWzfptI/QDb3IjVZVer0eum7imA6ZhF6vx87+Ho1KjSD0\nmV9e4O6D+4RBQhhk+L7PhFMl8IbMTE3wgSevFjCbnR2CKETxhrhuCdu2cW2Tra1NLl08z8jzkFlG\no9GgUS9jmxa2aVGv1/noc89iGBo3b6+zPrqLoRiF9TJNuPba67zx2us8ZBCq43WkCqwuzTM/M83y\nwiLnz53Di3za+/t43R5eq8XBQRlbVwniCD9soUpBtVbjsQvnGY483r15g8uPX2Bwf4OPrZ3l/MKH\nmG7UaGouaZZx98EmQjcJvJhuf8AHn/0IlhHTOdjn2svfZnlpFq/Tolp2aTebPPbkk5SqFTRgbWEO\nW2RI32Nlboaf+dzP8t/8j/8t23vHlCoNuv1dvFFE4kv6vTZrayuUHZXOoEUcDzl3ehFFaFTKZQ6O\nfDQkrqnx7o11Dg4OimYylUitYFwcttq49jTD7T5ulOOnHo+fuYTv+ySp5GD3iDSSJDKh2xliKiVs\nS9JqHzIYRXRHPSbm5hmGBq9de4WDwz0W5uZ59tlnf+DS+UNRwAs4R4amFVaxJEtI47h44OgmUZoU\ngA5VQdFUZCzRHs5r359oJQokap6l1G0LPwxQFBUpFEqOQTgK0TWNLM4IpWSiZmNqOXmkEAz7hEOP\nkqnTCkcoqs5wJNENh17Xw7AtdF2gpilCzWkfH1EybYTM8AZD4jDi6HCXRr1Ongk0VaDrFt3hCM/z\niJOQTI7hJeRYlkW9NoFbshFSQTU0Epkik5QsloAEkROlMYZqIHMFkeiYuYamQOqHkEMsE5I0wtUs\nfOmRRSmqmZHGkjiGVLWIMOhGCalq0B96lCplEqHSj0C3FQwFHBV0kbE4PcuGCjJXiIKYy5ceozWQ\n5HYZy7HRREoQDLn4wYv0202+81cvUy3VeOapZ3jp219lfuU/oF6vcNhsY1gWaRpjajqqJpAqqLoC\nY7ytZqmYulaMbdUUe6xZSEQh7rJUgY1AQyVME5JUoowLURQXegFTZGRJWMBSTI3BwEc1HBRDI2FE\nmgg0NNojn4qXIdwp/CjDFw6Z54B0AAAAIABJREFUWkxrSAsuvalBEPrYToUIge5WiKKILElJpCQc\njvCjGNsbYOlweNgjiXwG3SNUccyUa2PrGTIeksuQwFPQlYw4GGHpFqmM0TWDKAqJQo8sfwtmzpAk\nkl6ny+bOAZ1OETfbPDrCsR0+/NxzfPOFF9nZ3WVqcpIPP/ssnXabF771TTrtYx4/d4I0HBI0v0Zc\nvUhl7hz71U/y4u/+HZZn6rz00ktcuHDhERVKVVUs08CyTEajEdvb2wghODo6Qspi6jUxMfGISPfQ\nUuV5Hv1+v+iqJyYYDjw8b5tqrUL7uMnMzBzN4XCcG5DT77Sp1+vUarXCW69qPH7pIq++8j3W1laJ\n4xjHLgrxaOgzUatzcHDA4+cvcHjcpN1u02g0uHTpEoPBgJs3b7K0tPTIoVFMCywGgwHlUoUgKixp\nQghCz8cbeNTrdbSyyXDoMTjYp1ZrMBgMsG17nCtukaQpp06dwg+9R1MhVVWLIKA04/bd+5QqZRoT\nE6RJQpaF9LsBa6tLYwCRSpgkpIOcWmWGiqvRbLYwTJthf0QmKYiAeY7necg0Ynd3l+nZaZySw7lz\n53jnxi1UrbBgttttTtaXgYxyucza6ipxFFFvWBweHhLLlByNq1ef5OVvv8L8wiwn1ibY3t1BkGGf\nO8Xq6lOYpkmn08FU4fKlSywuLvKtb7xEImMywHUsoqCYAl58/BzPfehZbNtGkHHn1k3Krs3mzja9\nfgvfH7B7uI+iq6iWhlV2SaIYTTGxbQddMxEq9Pt9ck1haWUNub1Fp9fl9Pwy3Z1dzFjla1/6Mrul\nEqga0zNzXP3AM6Qy58c+85O0uz329/e4cP4McewXZElLp9Vqoms6e3t7qO0janMrKKrk6HAHEfh0\nBkf81m//E5790U+yuHyCd956l53dLYKRz+zaCqZpM/RyVmbnyIINDo4PeOLKMxw0e/hegExS7KrL\n/Xt3mWpUMXUDRdOJw5iyYREJhan5OQ6aTf7uz/00ZdMkjmM2pUkv8EjzjH6ni+95dDot7u9sUdU1\nrpxdYZSMeP3Na6iuwdAfMApCDjpd9g+HWEabkmX84LXzB/4J/z9c2Vj8pKsKeZ7SbrWZakyhKSpp\nnGAZOopWFLicDNPUkcnYIz1OlVL1QjiWy0Lw5A8GKIaJoqrkMh5jNROSKBtHfao4JriWwXG3A6mE\nNMGPhpDD5GSdIBZ0Ol3SNMMAwnBEkgks3aJWLXEscnKZEQYBrVaLZ57+AK+//gZbW9vkmcDzApbX\nTiFUFcs2MQwDy3SwbacY/0uJjENErhNlxSHFREUoCkkaYZkKWi4pmRlxlKOrNrmELEkw9RJC5CT0\nMGv1AkxhlVBUMDWVNNbJcxvTsYmigCiKMGydcqOCrqtIMUGlLhgEQ1zXxFEkRg5zU2Vsw6Q39IsD\nk0jQ1RjPD3GdMisrs+xt+5imZG6hxk98+nls02F7Y5tf+MX/BD8KGQwOEcRASi4TUqGRSUGaJgip\njKEoybgwSLzhCKHoaJpGmmb4YYyhKTR3t6mXXSyhUqnWyYWCU67R7fZRNI1qtUbZdchkzNmzZ7lx\n8y7WZJU4gzSNMO0Sjm0i04jJ2QqGYRGFAZY7j8wcIpmh64I8C9CVBDXzWatZSMPm2POIsgjPG6LK\nAswb+R6Ts1M4asilx85x98afEvgDyja4hkKp5JCGISID1bAJQx/D1MllTPpwd0yCMhbmTZj7DLII\nzZli7fRFPvqRj3DtzRuUyxWaB3t89Stf5/r1N7lw/izf+c5fMTXZ4C9f/NajrHTHMqk3JsgQuLbF\n/rt/Rm16iUx1mV05x9pi4QOfnZ0t/PppyvTUFJ5XjNMf2ommp6fJ85xOp0WSJIxGI6SUHBwcPAo0\ncRyH0WjE7Nw0rlOm3eoihGA0GDIxMUmepZRsC2TG5ESdw+YRd+/eZn5xgbm5Odbv3uP0hXNMTjW4\n8fa7VKtVFhcXUVSwLZc7t28SJjGvv/kGrusWyVNRxGjkj58ROf8PdW8Wa1l6nuc9a572Xns+81Rn\nqKknVjfbFLtpik02BVFUoMgyHSdy4sCBECAIAgRIYCC5iBD4wrnITYJcGJngxJBtxZIFhaJlsmWJ\nZHdz6O7q6q6uuc487nlY85yLdaoYBwgShAhAr5tzCqgDnL3P2uv//+/73ucZDAaXHnCT4XCIqeko\nokR/0GNzcxNv5mDbNvW6jSxJJHGIG5XtmIpdJU6S56/7mX1sNB4zv7TIZDbm5OSE+eYc7Xab6WiM\nbdvcf7pHoZR2tWatiq7KNGp1NF3CcUMG4xFPnjzhyupVFFKG0YBms02z3eHp3hG93rCsCqQZKysr\nDEd9rLkqOTmrq6v0hwM6nQ6Hh6eICCh6OXhaFAVPnjyh1+uRxCmu62NaOoEbEISwtbON+8pNbt++\ny8aVLba2tnhw/zPu3LlDvWY9f43tdou79+6ztbHFxY0L7t9/BJQ2vu31DV56+QV0RWF1ZYlhv1du\nYtKYi/MxcRyRpeX9oFzm9n3fR7sEGzleiWjOs5xCLGg2W8xclycP7oOs8NILr9Oca/L9P/8z/qf3\nfsBf+sLnee2X3sL9r/9bKlWTyXSAm3iIsoKkSDTaLfwgYm5hkanj0Wo1qNRs4iDm7Oyc5mIDVVUw\nDYnV1SXUOEKsGUyDgJEzYe/H7/PeX7zHsNtlc2eT81FAq12D1AGlgzW3QM2oMIkTpq6DHwToVpX+\nZMpw+oAvfvEN1tbWiNKCuNstq61RwnKrQabp/NLrX8EfD7lz5zZ/+u6H+GLOYDCgohskWcYrL73E\njfYqH334Di1niDZnI1sS/cEEz/OZzgb86ltfQRQKbly/ysbGlZ977fyFWMBrllrms+OYMI1ZbNcQ\n8gQlz9B0iUKSCZOUvCj7qIIkEASlh1l4pqFM0lJekkQUSYwIyBSIQsrML9WJsiKjSBKWphLIEHoT\nEre0dIVJgkBOza6iFilB6DIahRRChU6rTZSEhElCa75DFubM/ICiKKjVagwGA/7snXcwtbIsmaYp\nplFh0Otx9eo2flz29oWiII1D3FmCKCsgCqiXA15lyyAqtaJ5iUtV8pS7H/wIZ3ACQl4uvElaxn2M\nClmSYlkSSRJRkJEVZc8yiWJUUSK5fEhlWYYgSswm5VBVEsfokgJiebJCLHOTpqWztb1N3bDwZjMa\nVY3/6nf/c5IMqrpJFhfookiWJaUJTniGey052/VWjWazyWAwoN8flqQuRb3sWyfwTKVa5M8z/s8m\nynVBIC1yEGUiz8euWty8eZWz2MMPgnJ61jARZI0wTi5TBwJGYw7SiB8YGuPplEqzQ61WI0sC0iQs\nc8ZFRhIGNKoW1dBj8LCHXcgIUkSaC4iChmIYnJyecnf/j5mrtQkEAb3ZoWJUiByPLI5YbDZYqUrs\n7p9zeniIZZh4/oRO0yL1HSYiuG6KIBZsrC9RXE5RS4hIQjnFnWQJAhK6ahJ6E8LgDvriF5jGOvfu\n36PWqHH/s88YdLu8+eabxEnEeDQgCgPu3/sMSZKZn5vn2rVrrC4tc3yyB4KAYZnoukGRpSDBztWr\nuL3HuJ7H+fk5x8fHzM3Noagq07MZgiAwHo9ZWFjg4uKCZrNJUZQtKN/3EUWRpaUlDOOZW1tjaWmJ\nJ0+eEIbHLC0tcXZ2RqdTR1UVZrMplmVhWRamaFKv23xy7z4ffvhTfuu3vkVGQRT4tFotXn755fI+\nTBLOTi9ot9uMx+PnUJkoirCqFQajIbKkYpomzWaTBw/v02w2SS+HS8fjMYsryxRnZ7iuWyJbxZ+d\nzh3HIZcKdN1EEhXyLGFlZRVZLsvmQRg9P8WLoowsq8xmMzRFY33zClM3oH75vviuRzib8trnb1Fk\nKeOJQ6uzyO3bd4jjiL29XZaXFmg0ys3CZ/fvM7+wgiSdoir65QBgThLFLG4t8eDxI7rdLoilMS3J\nSqhUliU4XkCSJIRRgvBcPwydVhNHdMnT0pB269YtLs77/JM/+CP+9d/4dbZ2tvGdCbKsMplMeLVZ\n57x7UT77ZJnFxSXOuwNc10WSZW7sbLO+tILve2RJTBz6eK5Do1pFkyScyZS6UeWFnWt4UUBVM1GR\nIYpRahIDZ4puGKiyQpHBeDolK8rqWe+sR+C4/A//8H+FQuTPP/mI3/ib/w5+IlEgYlVkprMLECDJ\nI+Jgyub6FiIyc51ldh/fhzRjc32NNEmxVJOGVSNxXa6uLNPQbfxhn8FggKTr7Nx4gY/u3ONrX3+b\nw/0DmgsLHJ71MVHQjDqffnqH+ZUFoiTADQMarTmapoGIxN7+Y57eu83q6hpmpUownaGoMlkiIhBy\n+Og+33jrbR5/9pTRyTmJmzM5PwJTw+mdYzTahFHI0cOHbL10k9duXGOpbjAZHTIY9Hnz+hfIuhNe\nWZ3nV37tLeYXl3jwZO9fEij9f71+IXLg3/3ed3+3CGZEzpA0nHJ+sscf/oO/z+79u1RskySKEESF\nLIecnDAOMXSTggL5GfQkKxdiscgokghdSlDkgjTxUUhRhBwpTxn1L5DEDKuikXgeSRgjSQLVmoHd\nsEGE/uCMjfVNPvroM1RFptu74OLsjCLN6I+G+F6In8SYhsXTJw/wXY/W2jbf+q1vURQinpdgGha6\nIlNvtklzgUyUyCMfKQ9JYgfDUBEkmSBMUBSJQkwRs5wiF8oTqwKGFLCkF9y80sY2TW5evc7mlQ0s\nDTZWW3RaMqYpYkkKG4sLLLdsbLmgbSpcW1lASj3uvvd9thdaTE8P2F6ZY3p6QMdQ0QiYnJ2wvdIk\n93pcWagxPD+kbln0Zx7d7gBLtWiqGobnUvc9mgUYWYKRJlhZjpFkVHIwkhQtihBmM8Jen6g/wC4K\nXlxdZbPToSYK4DoYWYotQE0UqAPVPMcuCuqCQEORqAkFHbmgJmTUDJkvvvkqiyttFls1Oo0Kr1zb\nYnmxyfrqPCtzNeaaFV7caBM7XV576Rrriw1W2xqZ22VrtUVTSajgMqfFvLxms9WUuL5UQ4pmHB8+\nxQtdklwhjASCNMI2VaTUY3XRomMrnO/eIZ+d8cp2BzG6wOk+4OLJh8jRGFM1ufvpp1y/foW5qklV\nVzg6O6FaVZDElNsf/ZSqpdPrnXJ48BjdFAiDGVZFYzTq0ajrfO/PvsNLn3sVX9mhKCCdHqBICo8f\nPeLgYA9BEGi26jTqDd5+++scnZyxvLJKmmfs7+3y6d1PWV1ZwjQN7n76Gb1en+bGa8iaRT28z/B0\nl/54QqezQCaI9Icj1tc2OO9eEIQReZ5TtW00vZwUl1WZAoFGs4lAwWg0ulxoM5zJjPOzczRVY2Fl\nGcf1kGSZvMiQZInxZISm64RRyHA4ZK49R//igjAIGfZ71KtVDg72qFfrDEdj3n3vPQRBoF6voygK\np0dHl8hOWJxfYNDtEfoBlmESeB6jyYiqbVOt1xBlib2DQ3JAkjXOLro4ro9pGkRJimaY5DlMHRfX\niwj8AN/3SdO07IN3uxSCwNH5OYpeplUiP8LQTdbWr7C8usaDR485PD3FDUI0SUGXFDRN49HxaRlP\nFVXOe2WbY3NtE8NUOO+fM3ULlteXkFSFw6MjTk7Oset1ijxlbX0FUZTx04Jur8fW5hZhGJOkMJk6\nOL7PLAjJihzVqNJstjGtKlatQhIn+F6CaRr4vsPiygaKYSIpMkIe8/TggPd/cpvf+fd/h7zI8TyH\ntbVVbt68ye7TXfIk5+T4hKf7B+WUuQCvv/ICUeSj6hKhP0MRM5YXO5yeHSMIInqlwsnFOY+ePOak\n3+VrX3+bjz/6CHc04fDshLnVVVrVGoutFpIiIWo6iqrxk0+fcNgbc+f+Y1770tt8dv8h5xddXv3C\nG3iDcz755CeYNYPJuIs3Oudrv/wlPvzpj3h8dMyVnR0GoyErq2tMPY/RbEal3iJToRBS5ubm6Z7s\nc9bvcdIfoHYWeOWLX+HJcQ9Lr/Dgk/uc9aZ8sntKIigcHx2zd7TPxCs49Av+47/73zDoTXn64W2a\nFRnbsjg4OuRXvvpldh8+4fx8SLc7IPQ9othjqdVm995DXtu6TqXRRtxcYc+EF1/9Gi++8BqbV67x\n+dd/iW/86jcZ90dMz3rooUIlN2lVOrz9xlv8zd/+NzErMs6sizu54PHDe5yeHpAmATe/8NV/9XPg\nqiyRhgGKBJ7jYFcMRCHn4OkjfvOv/zXcIEdVVcIsp9GoI8oCWZjjui5RnGAoKoJYEPg+igyGpiMV\nCaqqICYpUVbG0gQBqoaOror4wYyKZZOqEWfnx9QbFufdU/KiZIgfHRyyMD9PmmVcv7qJ40UkcUoi\nFFQqdWJB4OTwCFGWECWJ2WzKaDJDvXwgmIZEs9kkiiJQRJIso6qrxL7DnY8/4AtvfBlRli45yBmC\n+MyUpuLmBblYEGYxhpjTH4xAlBnNpiVxVlaYeiGSAHkEhlIhCnIkBQRFx/VcjCymyGFjawtZUtjY\n2ECSJdaurKOIMrqS02oukItpaZASZK5fu0IS58xcn7zQyBIZWZCJi5xIUgmKGCW/5I0X5UknzTME\noQTVFEVZETEMg6Io2DvYR9dNas0G6zs7nBwe4LveZY9RKp278mXWvSjQFI089pFUhVQE2dQ5ONlH\nyWQmwwlFKiJXTUaTKc1mk263R71ikCNzfDHA8zxqFZ3ecIRVa5OnKZomE856XJzNMM0KrhOUFQyr\nBoZOjEgu5MiKQJJGBEHAYOKQJhPWl9epVqvc/fQToijA1FU0USYLZyiiiS6DNxuS1G1SPyeKAlRy\nwiDGVAyiIMbUTYx5HV0zCdOQd975FxiqjucsMB5P+fNv/3e88Fd/BaWySO494v333mdtfYPFpQW+\n/vVf4b3332N/74C9g2N6F11G0ylFlpElEZJY0O+XWsTyBhJRlPIj7TgOc50Ou6cXHJ+dcu/eA9bW\n1vjpRx+SRAHNZpNqo1F6tqPoOd6zUrUwDOMyz6wQBAHD4Zg0itF1AyglQqqqomkaSRIxnU6RJOn5\npPt4OGJhboGbN24wHo8RsgLLMBHFNlmWsb6+Tn8w5PDwkJ2dnTJrfnnKzvOcOIqQRBFJFInDiDAI\nSnJaHGEIYFomi0tLeF7A3sEhrUb5c5VKpUQk5zCaTRkMRzQbbSRZ4Pz8lO3tLSaTCa1Wi+FgTJrD\n48dPefHmDebn57l39y6mWeHp0z1EWWBze5sPP7zNJEqZDQe89dZbPHz/hzQqdQRRZTSaUDEtFFR2\nrm5i1ky+/4OPOTo8YfvaFh/dvoMglUTBxZXlskcsyKwtLTGbzRgOx3iehyzLxHFClCZIkkCaFciS\nytrGJrPJiP2DXRY6nTLbr5uomszuwQELi6skacrOzg4PnjzFqhr8p3/7P2NjpcN8u8nq8iIVu1oa\n6i6nzTvNOl4YEIcRjaaNbhhkWcZ0MsCLXdqtOooiEyU5pqqxsbJalvQlkTgI0QQJL0qQJBVn5tMw\njEs9c8F40qfenKcmFWSmSi7EfOGFHXqPPmFrrsof/N7f4+rmFTptm+FogtJpUtE0Hnz8AfVGjde3\nr/P4s8/on55T0VXqpllWD4RyQDLyhhiSzJOHj6g2OsS5gGE1qNbnWVNU3v/++8y1mqhmi2WrTZxm\nzNsGtbpO3j+l0mly7/vf5Wa7ib6xydP9hwTtGf50zLDfxXddTo6OyCUZu1Jl0u+xtLFGVq+y+MVX\nufcH32bv7ABRhq0XanSfPuWjn/6Io6OInV//df6N33oFwQ1JVKhrMrZtI0QhU/cRhSRTq+gERYGg\niMxXLFQp/79bEv9fX78QC/hP3vsxsgyyUmaBdcNm68Y1tm7uUG1VONvvUbUqFG5K5AqEgYte1ZAR\nCPOcIC2hAIUkkqkWfupjoDIej5GVEvUZBTDsjyiEnDivkcYeo7DshduGTeKlLLSW0EwNXddZWlri\n03v3KQqB8agHgoLnhFi1GrPxDNHQaNer2LrJxUWPL29vUbV0FEUizjPiLEe55BqbholZCORZxNnZ\nBRUi7t3+Keu3vkazIpHEAlEhIEsSVUXEzCARdFR0ZAHiOKS5sIIXhORpQtXUGQ27VG2LRMwRpJw0\niSiSgrptkPoqYp4jI5DGASenXVrtGt3dIWvri5yPhji+w/bGGg8fPKLZnmcyuGBxeYWgiC8z3QJx\n5pMWCqKYI6RlNjQvcqTLrH2R5eUJTBQRRakUlBQF4mVbQ1NU0jhi0L2gf3HO9avXkCWJ8XhMv98n\nS1Myyo2AJqnkeYouqYSUsw1yoVBkMl4UU6nVcV2fVr1WltNlleloTLq1WfIACvBmU2zLwPdKVaOQ\nh0SFj5wWuH5EFhZUqyaKqRMUCVEuIpIhkSIiEwkaqRyhVNtUFZHRxRmnZ0eIIqiyTJakZSZd0FAs\ng6wQSPwUSZMZjIbkfkEU5sxmHqIocn5+TtW2EPKcilH2NQ1LpTfsYcfNMuomZ0zObtNYeZ1Xf/nX\n+M1vmWQ5HB3v884773D7o0/xPK9E50siaRxT6m1kKrrJQmeBPM9RNRlDU57n5OuNJk5vwKB3gSpK\n6KqIM+2TC3Btcxt35vHwYJ83v/QGSZw+R5omcYRIgaTqiGIpO9FVFd8Ln/fMZ9MJC0uLdLtdBsNx\neXIWRTRTwuv2yQs4Oz9HUjUkVSshK3lBrdVmPHYQJZn5+XkePXrI/sEuG+ub7D9+hKZprK+v4zjO\npWSkRpwk5GTUK1UePX6MqyhkSYrremxt7kCyhyRdtoqSCC8ML2cpygRHkaesrW0RhiGHh0dcvbrD\nZDJhPJ2U8pN6nf5wVNr+8hRBgmazzrDfLcEcdpXJeY+lxRUUQ+fK6hpmVaU3uiCMEqpVmfZ8m8OD\nYxqNBp+/dY3BYMz5yXvEYUq9bnPzxWtYmkYSx4iSjGYYGJaFbpaT/6WURSmBUpSZ7PsPH7DywQq1\nqsWdT+/wws4LaApI7SqaVSETFE57x1g1k06jjlrROT/vcvfuPU7P+5ye9/ntDN57589ZabbJKFhZ\nnePo8AQxitBkmW6vz1zDYnGuRREpTBPwpyOaFY3hxGV9boG9PEARM1x3inN+xBeu7/AwS7jf6yLK\nCr6bEdUKxtMR54dHxEFObWkOxQk4Ojihoupc2VhDUTL29h6jKAqykJL6I6S0TLH89MOPUE2DebuB\nnMf89r/1V1hdXuJ7f/onfHr7AzYW51hd3OFzt77K3sEhIQpmYSGZOq1Wg5WVCo3U5sXlFdz+lO++\n+zF3T0YgSESE5FqVr779RYo0ZnDe5cbVOe5OTxFmI2aeRzYtUxhpkYFcJoAEQWZcwPbV60hFTpGm\nHHefYFclJgMHfXqPG6sqX/gPf5N2vUqRJWRpQFFYKFpOFIR4kz6iJuJMErJcQFQL6qpOGIbkRcpk\nFv7ca+cvxAI+GQ7I8hCrUhqhNNWnohsEoUO/N6RqWcRhiKwoeP4MIYspEgnfdbAsE0OXkSVIkoh2\nq8qk7zA4O0JWwNBMev0LbKPKfKfGwfEhC6oNmoXZ0HHHUxbm25imzsHRPrZdIXBdvNmM3sU5umlR\nsZukGTSaVSaeT46CgoosiOi6Sp4mJJ7D3u4ufpyztbWNpVukUchoMkKrZoh5jiqU3tq7tz9g49pL\n1HQFIYmQChnSgjRLCcKYXNIJsgRLBhGJKPRJwwCpKEoYTSagSwIVVQHDwJl6xFmMAgiyRZRG1NU6\nUJBfAstM08S0StqVaerEcYiiaHRac2imidLpoCo6WQqKJKGIMpJQKmGSjMuF+Wd0uGcGWFH4mY9b\nhOcKVPnyq3rZgxclkUcPH2KaJnNzc1y/fh3P8xgOh3ieh+u6aKZGfilnSQXpORVMFEUi10fWFLIi\nR1FLNrlZraDq5feIAoIoM5vN8H2fIAoxVQFJljEMG0NS0CQVQSgYTV0SVLK8KPn6eUZWFHhximU3\n0TWVYfeMs7MT5ltNiqIgjSMUSSihNRSEgYQoymRZfknYK0r1raSUfUBEKhUbXSunvSuVKv3BCZPp\nAEESOT45ZzpNuP/wIa/Wvk9j5XUe749Qkwknp2e8//67HBwcEgQRoiigyCqiWLrLhaJAkgRkTUTT\nVJI4QdO0UjDzrKUUR4SjAV976yukeUGtatOo23z7299mYX4eZVW/lO+UiYgsy+h0OvieSxzHiGJ6\nOUTmoikKSVJCVlzXY+JMy7iZ46DrJdmsNxhwfHTG8uIiqiAy9XxWVtocnZzRHw25ur1JFJUylNF4\nhmmaaJpGt9tlOByiquWG+1lk7RmrXJSkEjSTZiCUA6wz18FzPPYPdlF09TnIpSgKfNel1WrRbDYZ\nDodIUnkftVotarUqBwcHJftPKLn7zbkO66urTAYDoigp0bKygjA/x+H5OZJQ4IUxX3nryzx48pjT\n01MGooxq6IjkiBQkkc/y0gKD0ZBbt27xv/z9f8Ta2ipJPEGyFRYWFjAUlbOTUyoVi7l2m0cPHpCm\npaI2p3Sux2lCnEHu+Nx68XNsrKyTFTFvvvkms7FLEPp4Ych0OkWxGzQbNXRFxp9OSTyPv/U3/gbf\n/+G7fPe73yXwI/63f/pt1ls1VpYXUXWNjZUlTg4PkRWRIM5w/ZCGJSPnMUXk0rSr2JZJGoVMh1Ma\nts5K1kBRFKauiiSl+O6I1aV5bu8+JA4aJKLKYOwT5jqBbCPU53FmJ7ixwBtf+1X+wR/+MQcHuyRp\ngCBbJJrNNIR5q4ZtVdBlifnOApKmM+hecHF2wl/5136N2XjIpHdBOJsylqEzP8fh3hNOj09ZWZrD\njxLIC4LEZTTrkUcadq3Jzddf4Pf/6PfxJgNkTQGzip036B/FNBoNDC0hyqZMwj6JElJbW6dpSkzG\nM4aDCZIgkeVZGWvOgdjj7k/e4WjvEctW+VzZvrGIjEcSBuSxw9lhD1NXsQydXq+HYdolyCuREJ/5\nIRCIIg9Nr2AYFp7nYRjWz712/kIs4NWKye7eEZa1hO+5fHrnLoIgYZo6b3zlbabDCZkASQH1ShXL\nMJmMJ6zMNzk6PsQvEiy/gUL2AAAgAElEQVRTIwlDPjt8hCGJ6IWPH0Yoas7161fxHB9D06hUr6Ia\nCqZpcfjkKZIkMBp3mUxFJuMBn7v1Eg/v36NS1dne2sBxg7LE3pxjNO2jVZuEQYhmmXTaTSShwNAk\nImeMnKcknkfNqqGqGqplcH56AJEFkkKWBsTeFOKIqixQkdNSeCFKaLKGoEiIWUFOiqyIZEVCIZcD\nbnESIUsKYsHzhS2KIjIhRLiM2MkyuL6DKJeyEFEUURSV+fk58jxnfX0F34+wbbWctJ2UQ0xBGDFX\nW6Y/nqDrFVS5fGALBRSFXWa1E5AE8V/6u5XQnPIqijLrXcpMRIr8Z/8Wnxm5DIM0TXn69CmapmHb\nNp1Oh5XVVVwvZOxMcPo9kqIgkwRyUSQXRdIkI6N0giOIZaWlEPCjmMFkwtTxyIryAWigYZoVatUa\npioT+D1EUSx7jUKKopYRIUXUiJO0LAeKOfVGA8uqU8gG5yfHKEKOLJbylCSMEYqsVI+LIpJQvj95\nnhLEIWmeYRgmw7FLToGsaARhAoXEbFaSv6YTj8nM5+DoAscPufXqF5l6PltXr3Bw9zvc/Np/wiRU\n+ce//w+BUqFZrdpQeOQUqJqOYZikcUKRZ+iqjKlJUBT8s+98h9XVVWRZfb6A37n/GW++vE0YxhSi\niOe4HO7tsba0xP3797n1+deo12qYhoXjOMRxzGg0wnMdWu0aqqjTbrdJ05TZbIbnBrTbber1GoVc\nDrs1Gk3COOX+w8domoGuV9g9PLocmFpENw32Dw8QZYmHj1Oa7U6ZSdfMMl+flkCL7e1tfvSDd3nl\n5ZeJ4xjHcZ5zIFTNYGNjk+F0gn5Jymq1WuR5Tn8woNOaQ1EUKpUK4/EYs1JhOp1iGEZ5Es8zut0u\n1WoVTdPKAbhmk+nMpdaol9Gs0Kdtl+YoQRDK2NlswtbmDo+ePOaFa1skSUlAazabjLoDFEWh2rBZ\nWpzDc2dkaUyz0WE4KDno49GMNBOQJKXM008uiXHjFFmWkUSFs7MzdFWj0+mgSjKFWGJ70yRDROKb\n3/wmDx7c5ff+8Y9ZX9vEz2IGwyGypDA4P+O1t7/Oowf3WZ1rIrSaiHHAr3/1K3jjMX/+/R/y7g/e\n5wNZ5Pr2U26+cJWDk1N0y8LxYiRdYjR2eP3GOrqQsL7Ywgkz7GqFUb+PbShUTQlBtMrnTaeCH4zx\n3SHj3oi5hkmjKiLnEdOhz9gPMFQN15tQqapMxn3+1u/8u/yX/8XfYeqU+N7eoM/80hpjd8ZX3voy\n45M95uoVvv7WX0bULCb9cxY6Nn/37/wulqFwenzAzpUNhCLnn/7BH/K5V1/hjS//Mh/fuYco6Iwn\nUxJviWTmsbf/kJ/2h3z2059gWDo3VixW11d48eo2CjGnZ8ckmUAhCVyMDnjj7S/w2b27LF5ZpTlq\nIuYKqlrGugRBoChyVFFgcHbA6PABXu+Iui7hnJ0iBSMKpcbu073n9/roYkyr3kDEJnAhDmJUVcWJ\ngufiHlXUcWfec8VtEPz8J3Dx//m//P9/5Xk5edqsN1hZWiYOI+p2DU3RSUO4srKOLkE8G6EVMVvL\n85w+eYo7PGNzsUkwOsfpHbPcNFhv61SkgM3NK2xvb5MW0B+NMSyTNM+5uDhDEgSc8ZjlxQ55HiAS\nk6c+rVaD0+MjPN/h4vyUWtXCmY3RNZkiCRGKlMj3qFUtKqZK3a6hWyZxEuF7Dl6YEOcCQVIwnAXM\nooJC1kmQsCyZvacP6J4es9BpQBryg+/+CVIeE/g+pBlFmiFJCnkGWVyQZxJJJtJsdciz8uRnVisU\nAhiWCaLE5voa08kQSSiI45A4DBHEcvGUZZnj41OGoz57ewd4vsPe3h6Hh4eMpw67u7tMp1NOz7uM\nphOOjo6ZzVx0U7u8iQvSIkcQpOca0OeZ+//LVRRFOWWdJCUG9v/0NU1T4jgu5wGyHEs3noMudnd3\nefTwIePQw+60Wbt2FbvTIZdl3DhE1ks9p6qqFKJAkiR4XsBoMiZOU0RJoRCg1qiX5V7dRL7Ut2Zx\nhpiXKtVnr8fzHDxvShj6mFaVjZ3rtFe3EM0a5xcDPvnow9JmNRqiSAJ5GlPk6aX4JSaOwssSvohV\n0fE8h9lsRr8/JApT0jjB9zzytGA0mlCkObPxjDRJ2Lq2ysu3rrO+uUaQxmSCiKzo9M/2cQdPEESZ\n9vION25eZ3l5ha2tHexanfnWIjWrwnyrgV3VqDdMVjeWuHbjOicnx7z62mvsHx4Sh6XUB0DNZXbv\nlyVLXdVwZlMUVeLKziaFUHD79m3a7fZzdOrRUclxXl1dLt9vvdxgSZLE6voVzroXXFxc0O/36bTa\npcmryDnc32UwGjKaDEuDmyhydnbG6ck5FbvO1s51fvLBR5yd959nop+dltMk5/ysi66ZzyfRS9xu\n6Sp/lqBI01I8Uqs1mDou0+mUTnsOTTMYjkf4YVBWZi4rBVPHYeqUYhRRFJEUBdcv4UmKoqAoymVs\nbvQcH6tpGpZZ5cPbHzOZTCiKouTEez62bbO7u8ubb75JGicYFZ2tq1tUqxaVSpXF+SVqtQb9/pAf\n//QDrl2/gReE+FHC1CkRtINBiVw1q+Yl80KmUW/xV//at4jTBN/3aVQr5GmOIIoEaYzrldl0UzcZ\nnHeRRQlV1hDzgvFFn7pp0jQtUm+GnIdM+6f4kx6bi03+g3/v30YXwUtz7jx8wu/9wZ/wwSePOemO\nccMU3484OjmhVrHIwhk6CYYCQpHTtC3mWlU6TRu5SGjVDVaW25iGwNVrV7hxfZNf+dqXePWlHV7a\n6nBjuc6rW3O8esVms5ay3sh5/UYHYbpPW4+5uTrHlVadN156kU61idefcm11h1F3TN1ucXZ4wvHu\nPt9954fMZjHn3RGdzgpvfultdKsJUoWda1eRVZ1Op4MsCmysrnDrxk3MBL7/R9+hYsmoesHW9gbX\nr6zyypUV3v78qzQklcDx0SWNcOajIyHGEZaY8YWXrvO5tSY3lmxcZ8zC6mI5v3OJu9bkAmc44u5H\nH9M9HXBy4VJvr1MUBpPxlM3NTdY3tzCqNrX2PKmoUEgqF+cjpk4EoopiWKxtbiMoGqKqE4QRUZxQ\nqdpYlerPvXb+QpzAEUV0w0IQVVStjDfZtQaDwZDBxTlnp/ucnB/huhPeHQ5p2U06zVU++WAPS1OR\nKEhl2HX7XNu6Qp56XBwdMBj1ses1Zn2fWfcCQ9cZ9nqQXaI6ZUijiChwWV+7wqNHj2m1G2RZyng8\nwvV82s06Fxc9dE1GEg3SXCaLQopQxnFnCIpMmufEUYiugG7VOOuPQdKJggRNgSx0SFWNiilz9+KE\nhVqFp7uPWb9RJQymaKIKiUAYpyiWBalM4kcodQlRzojTELIUsgxVlkiElNlkjKJKPH34gKqhI5Bi\naSoIGe6sHMaSLqEc7XabaqWJbVdZXV1F1QQUvcq169dLyUOtgSrC1lWdqV+a3HIRBEVGkESSvMTe\nZWlSqk8vy+blYl7uJiWxRDNKl4u8pCqkWTmh/KyELlxuCKRCIL8cgnu2GQiCgL2Dfa4sr1DvNLHq\nNpIgIxYxsiThOA5BELCkKCRBSK1qo0gSpm6gqxpZkjIYDNAXyihQHIQomoIfRshSBmmGIpZoXcNU\nUGpNNLvNYDLl5OQYCYFCkDFVCVkETdPYf7KPeWWDOCizyIIAaV5uBrwopigEirT0mVerFlPHew5L\nSfOMuVabeq1Kr3+ObVf46MOf0G7Ns3/UZ3RyxtVrN5hOBrRaDXL3PrR3mFu9yVo9JEtz1q9sEoQx\nmSgiCQWWoRGmAQtzHaIg4LPPPmVzcZ6drTV2D/c4Oe1eCmbA2vll4uN/hiQrHO8f8OP33udLb/1l\nKs06n7t1i3f++Xd59ZXPsbe/j2lWWFtboygy7HoFTZcIw5inT88RBAFNM3jllVcQxZKWtr+/z2g0\nwrIsms0GfpYw6PaYTYfYls3y4gIPHjyi2Wxx7eoN3n/vx0wdH1k1qMnlYJxlVWi3O9i2zceffIaY\nJQRBjlTq6ZhOpyRpiiCUf3vFMNAtk6WFJXr9PgIyum6i6+C6Lmmac3V7h6dPS7604zi88cYbfPzx\nx6hZVhIaxTL2eXR0RL3RInI9VE3GqppMJhP6oyFzi0ucn5+TRAGDyYQ4jnFdF6HI2NRUDE1hfmWB\n23c+4dd/7ZvEYchk1GM0HOAELlevXeHevccIikp+aT0s8gxNV1iYm8eJAioVE9VQERIBRJH7Dx9i\nWRbOZFzGacnRKyrDaZfZZIguixiqhiqJ6IKEqmh8+S+9jhAntG2bs5P7FImFsdSmYYjk4YTV9UV+\n+7fe5s++/2Muei5mzWbkx4RJgSrLiEVS8i9kaDXrSJKIqVrEOWzvXCF0HVRNJooD5hdaqBUTQZYQ\nNJG5xTa5Am4W0jQstCtziLJK6DvoVYNckMmygtnJp/z1b/wl0lwiSURUVWfkeixWRcZnu7iTPnmW\nkcYOcZqwvbPKeHrBN7/xNsPBBaKksL19hePjY5aMGrKhsvvoPnOtOkvtGmmckSUxvdNDOqd1TMPk\nyq2b1HSDIo/RJJneZIZh2uSFhIjAoDvAMLWSTZ7FDJMUKdFwpy7TiUOaliCfQswpDcM5i4uLuH6I\nE6WM/QJyEU3TUA2dnIIki6k1G5wdHZcxyopGvV5HkCVkQWLsTojChMXFRcxqBU0r8d6C5/3cS+cv\nxALuBD5pLnBy2sW2bWRJJQwjEAU0I8UQRITcQlxQqd7aIk8LskgkTVQC12Gu1cYLA8h8ImdIEfuY\nisxqu4ZuGliL7dI3LYpIiY/nz6jU2nz26W1u3LhOo1lDFEUa7RaTyYQbN194PuEuSwKBP8OuWORx\nRMUwQZHxwynmfAdFUzAsnTSKMfEIPZeLJ/e4/uLnSiGHHGObMj/4wfcwxJStnU0efnKbHJHHjx/x\nxhtfxNRzgniGJouknosq6AiiiJRkqEJAf3DC8vIqoiAz6J+i6ypxFCKhI0oi6SXQJhcK5ubapaLv\nUpxStUxGgzF2rc7x0SntdocwDOgNj1lZWODk5ATNqpIEHma1ynA4QpTLvnmaZyCXtjGxEChyoYzq\niSKFKED+M4d7nudkRV72jYAsS8vf4dKzXVxyzwFERS4Vopc/J8syRZKgShLT7oB+7wJRVVibX8LL\ny9N3u91GkiRs2y6FIHHZr8yimIppIgkFzXqD+fl5fHeGbhnkYoZWtRCFDEOpoEg6cRjgeh7JxMU9\nHZJlCRUpRxZEoizFsCq0221EAQxFJPadyw9cQZSUPmxZTtHUBlGYoigqsiJRsTUm04K5dhMBiSdP\n9mi168RRQKWi0+2dUW8uce/+fWbTgAyNO5/cZvPKKgsLc7z3x3+Pb/xHv0Ek1FhcrLO4sswsCLj2\n8k0Oe2ecnZ5y/+gpcRRzMZ7i9Pu0DJXVGzvs37/P5164QbfbJXVPkI0mwurXyJsv8PT0O5w+3efW\nrVdJ84z3f/wj2vUGL7/wIt/703/Ordc/z2zm0mg1UaSyjGjo5ab1mcUrzwvyAna2t9nb22Nxealk\nRcsKmQh5v2BjaxNdVnCnLhQir7/+Ok+e7PKTDz4uH4qKyunpOYvzHVqtFqEfoGkGg/6EzoKGLhRs\nbm4wnU7Lz2KryfHRKblQYFQsLro9FuQFMgp0TcMyTJJoRpZltBpNut0uvUEfs1JlOJ4gqxppXmar\nZ65HtWrRaDTwHYf5+XkmUwdF1ghcj41ry7gTB00zWFpdYXVpkdloyJ3792kvLOK4Pssri/zg3R+y\nOD9HzwkJwpyz0z737nyIbSq8cus6zfmreIGLLEtkRQQCzM/PlzMGkY6QF0wmMyxDp8gi2p0mjbbN\n5tYGP3r3RwDIpdaBdqtCHEzYXJ1nfe7X+Ivv/RNkSS5jeMMBSwt1iuSMlWULIZ9ncWGOF29uc3py\nQr2qossJL1/b4EsvbvLD9z7kf/8Xt9EKgTCXkBSNJEkJ4pj+YMDCSrWM4OUiznhGYepUbAvPcak3\nGiRJhpoX5HGEkKfkOUgZqCLEUUjm58R5gSwJiHGZEHpW2dF1A9U0UDWDw+MTWqbG7/7t30GRXF58\n6QqGoWFZOkWq4EYBiqTTqIGYS8TxGEVWEOUprdoCOeDN+mystvGDEbpuoOgSX/7qm7iBz2KjjiSn\n7B4/ZmF+CTeLcTKXw8+OsWsNRATqNZskSRA1A0OrISk1BmcjJmOPk8MTNK2kyol6CQezqja5VHB8\nvsv83CKGKiBLJhQxvdM+QRgzt7iAO/aoVeuQpRhVFdWU8H0fWZbRNZlmq4YkgmVWcRznOffg571+\nIXLg//3/+D//bl4UeF5YMo17Pebm5snynGs3XqBZb/Dijetc3dxiZWGFxbkF6o0WVzZW+dxLL9Fu\ntrGrdSxLxzZkanWbMAqxq1Xc2Yww8CiyhIplIogi8/OLpElO4LkICCyvrBCGIXMLC1iVCmGWkeUZ\nuqrhuS55kuLNZlRMk7lOm0IqMHSZ4WjMxB3x6NFDTKGCZVssLa8iiCJWtcrR8QmyIiErEktzdd79\ni3fw/ABBEEFQiJKUVquBXbERChlZEkn8kDwV0GSDyJ0gExFMelQti8B3icMQSRKIw5iabSMIEHh+\n6SQWcur1Ot1uF9OsQFpwfHJEmmTYdoWzkzOqVYMojJjMZtSr1fK0msSlBjBOqbU6eFnKoD+iyMG2\nTPIoQhXl5+AcuDSJiQICpVSm4LInLpSDbnmeX+aEC0RJvMTcXhrY8p/FJ571bP3ELw1dmYCm6eR5\nxvWb12nPd0jzhMlkwsLCPEmSXPZAs7KHq5sEgUejUafRaEAhoGgKVtVCEcDzHYRCJPRTAi/E9xxm\nkyGCLGBoKrJQYIqgiAL94YQMEdOyCKOQPE9Lh3MQUBSlhCYpUsRUwqw3OT094aUXryMrCXHis7e/\nx+rKFSazGWEUIisihqEgKQVR4mK3TI5P92i3W/T7pVO4Xmsy11qkU5NQF95AVKvoik+YeJzPJjw+\nPuDp06fMXBfTtql35vDTFLNawa5VWV2aQ5BUhoMxnuPRqYIQ9BGNFoLeIm/dwmytM2/4LC91ODo8\nQFNUhEJAEETSHFqtDuPxFMeZIoo54/EARTYwDIN6vUl4OSSWpin7h0d0u10KRM4vLnj0ZI9pEGNZ\nNt3uEFXVmToui8trXLt+kyRJOD095drVa4z6A+YX2jizKcsrpUjl4PiEerPBrReuUrNt+oMBsiyh\nqBora6vkec505pSLdK9LGAR4jsPUmZHnOcPhCMcpCWzCpQtBNw0uuhfohomsqPT6fdIsJwojFEnE\nrtoUFJxf9FlaXqBqWVCA64csLC8TOA5ClqBXqsiqxsVFlzCKCNOQdqPG3nGfwPfpnpxwfXuTN3/p\nNfIsplIx0HSDp/sX5Ch4gc/a0hLXtjZo1+scHh6XZXxJQlFk7n52h52dq7xw/QXufnKX/ZMzJFkm\nTnJ++1vfYL5msLbYwtIlvMGQ7c0tNEXnxRsv4jkOi0srZZbeNmm3W6U4JU1RVYVGo85kNKCmFuzs\nbLOwMM/dB4/JgSzJkFWVJEl5+83XWGzXcF2HMI6oWiaWWbqwPdfBrNlkSYYmKzizaZlsKVIszUBW\nVYRcJCwyJF27jBlKzBwXu15HUmQqtSqCKDB1Z6iaSppBq90hy1KqlQpWpYokyQiFRBb5VC2LKxtb\nzMZTWo02aZJCkTMaDRFlCc/3GI/HSJKM47gMxkPOuhfc3L5Oloa4/pTdw31ktcrdTx/w8PE9DDQU\nWcW2KqiKQr/XJ01SGs0WIy+kyCT2z86JC3BmHqPxBKta2umy2Gdrc4WV5QUsDQRS2u0WsiLQ6TRp\ntWpUbYNhv0utYlIUCY1GhSwOsSsGFVOjYuooooggZIS+h2motFsNTENl6foX/9XPgRsVkziOCIMZ\nz6QfkiQiCQIf/PgnvPzSNQy1gCxElcudTaVax3PHDPoXZHGKLInkacjQC9FUFQSZ07Nz7P+DuTeL\nkTTNzvOef99jj8jIpTKzsrau6epleqpn4/SQs5IcSkPSMwRJG5ZFW/aVTPvCgGHABgzKsGHY0AVt\nQLIgAwYImjIoUaBMyyRNkbP09Mz09FrV1bVX5b7Evv/79/vii0r2yHceXUwCdVFViIxMRMR3vnPO\n+z5vOaBSqQBgOC6L0y5xkmLoBi+99HFAMJ/OUXVJxfE8j6eH+1RKZfIiYzgckheCer1Ot9Oh2ztF\nNyxUS2Pn6ssoWUTZNRnMT9nde8iNG89x+Pgug7MDarUaFBnJNOStH71OrVFnPJkzGE1xLBuFnFaz\nztFxh1ykXLiwTqYJwsUUZZ6SzoeYKzFqmKKoJqot2Flvc3o2ZHt7g0LJGA2G1OpVGs06lmmzmMcI\nIceKZVcKezY2Nni6u8vlq5c5PTmBXHBh7QL3Hj5ha2OVNMkolQPu3btHxQyYTabkRUaWF0RRgq3b\niDRECJ0ikyIcdckPNwztnBYlg2bEuUgjz+U+81kOusTVK+ed97Nir2kaOtIKpqqQi0x+/ywlzKPz\n75OmcvUxmU1QFY3xdELR0BmNRpQCn0UcYbouJx0ZLrOYx4y7c0xDIS8EGgJHExhKgpbMIZNTgVQR\noGq4lss8SskygaKopLlCkhaATE9L84JCV9ByF0NXWdt2iYsDLreu8NbbHxBmEU/273N61sd1XVYv\nBEyTCd1ul263T35/gV+q4JY9mmOY7hXUKj4X1st861t3yde/w+VXf5O37h3z6S9e5vW3Xkd3XKrP\nXaJIUkSWY9su7SuX0TWdWjUgFDmOYtBMEqrP32Aw7LGx0aYzuI1eXCAz1lDaNznNn+fOO79PGKpc\nWW3y8OwxrfVNkumIk+M9ytUKpVKLyWiIZchADj+oyDWBkqKbOkcnx1iWhe2UGc/65JbNMFHp9gY8\n2jvB0HQa1YArVy5x++5tTEPn1VdfxTAVLmxtsLv/FJScnc11fM+iWvOJ4jH379/hFz73Mr1eh0q5\nLJ0MRc5iGjHoj6lUbAZnfdbbDS5sbEnHg6rKXOhOh8P9Ix48fMxnX3uNIhd8eP89ojBlPBywc/kS\n8zBk0B2wvblFySoYTmc8efKYWrlOu7XCj956myRKKZUb3L33Id3DE65f3eYrX/oy771/m70Hu5AV\n/NLXvsSdd+8zHHTxDZNf/trnaFc9So6HaAa45SapEjIfv4FtOlSDOjW/jKYrvP/ubTzfplUt88PX\nv80Xv/J5bnzjazhZh1K5STyfLJkQIQXwK69d4f33H9A/HDMej2nUNETcJ5wt2F0MSOKM/af5MiZ2\nwnvvvE2j0cDUDcgl4lMIQX88RZklXNxe5aufe5EPn54yiXT68wWzOCQKJ8xGklwnUrB0j/29x+ia\ni+MtA5s0XfLqaw2m4wlxnFCIhcSqOjaua+NoBmmc4Hk+rusSpzFFUdA5OCDJwPcqDMcjqvUqtu+h\nWhqd0zMM1cBybEbTDpVGHdf16Qz6CMNglqYS3qMpXLlymSe7B9iOhWEWDEdjfuEXf57vfO87OMJG\n2ApJqFGtX+Az9U38UsClnWu89c67bG9sMp3PwDLQXJfLH3uOLI9QSFgtBeR2ytHZGfVqhc6RFL2m\n4QxDyemcjVlZ2+KVF2/QGz2gWqoyHo5JxiG1ZlWeXbpOpWrJcKpCp0gT3IpLq9kmiqLziNIkF5Ra\ndRaLBZVq6d9I7fypKOAizbEsm2E6RFFUkiTFNOWNbh7JvWK1WkUkIboG5XIZUahUK2XGwxGZkjKd\njGnUyixmqoRM2ALPc+j1uwyHQ6rVKmkq9xBFUXB21l0quWX2dlCW9hW3KLh48SJxGPGtN75PuSx9\nxxUvIAgCmYyGgmFL20uj2sDQLdJYUCQZUbjguWuXePToEYd7Q5K0wPM8drY3mc5Dbt25g6IoZJmg\n1VrhW9/6Dgoan/r0J2Rhy3LiMEQtoFimrqmqSpFnUnEoClRNFjPHM8myDE2XsIgkjX8s7EFTVZlH\nrWp4rotj26w0msynM6qBT6NSpeqXyESOYRhcWFtHCXxMw0ZXNRKRLAutiq6ZZEUh7UpFIXfhGihK\ngaqoqIb8GZRlp618pOP+6xe6WAZAqD+2/87zHFM3EXm2zAhXyfOIPJWjbZAiOV3XCcNQRsNGCXma\noYqCNE1J0xRDMxBJuvT05ggKEkUhEQWaZiKSOUohiPICA4s0l3vtQi1AyOdWtQIhMgpVkRGgmiZT\nyVBRdMjzgjzPyMWM5288x3jQ5WD/hKBUpXVhB9MO+OHb77Gzs00qMrJC8ODRE1w3wAscWq0SndMT\ntlpNpmO4/cF7KGKO7uh0d7/H5Vd/k6C8SX864cq1a5T8CgWqZBnMZ6Cq6LqFqksssKEXREmCZlVw\nUVjRL/Lg1i2C9RaOrfHDP/8jrlz7MppepfHq32F+6fPcuv37VKp1yaAvBLYnY0YnkwmTyQxTVwnK\nVaaTCYt5wtXnLnHr1i00wyRLBWf9A3IKRvOIJExQlYJWrY7nuJiaTIV76cUXODs5ZTQY8uKLL3L7\n1h0+99pn+D/+4Pf5t3/j1+kvU88c06E/HuP6JawwYhYOMEwTDcFiEWIZBkLEzOdzXn7l44xGI1zX\nZTyY0F5p4jnreLbHLM6xDBOhCRqNFuWqymg0YjSaSFSqBhd3tjh+cp92qyWtjrrCdDKk1ayRRhnv\nffiQDGiVA1abLZ4+espiPicRGVkmiOaCLE8wVRmY9Mmbr+BoOfc/+IDxdManL15hsii4+YmXuHv3\nPuNhnzSNiKIZK606eZFQKlv86te/gmWrBI4MPRr0ujiOjWvZjMMQkBfwKIrQXY1KUMLRFMbTOaaR\nIgoFuyw90NFijm6obGys4Vi2HNuairQZ6h6OmhOnBaoiuHb1Et97+wN0bxXbcimY8HBvn51Wjd7p\nGfWVVYazCWGa4OquBM8sGf7NegORCwaD0RLNKvUJjuNQKILRZEgQlFF1lTRP0dAoVSukRYGvWZi2\nQ6VWJRYZiqZS8far864AACAASURBVKt4nsdkMsHzfSaLOWmasLrexvdL+KUT8jzHsWwOD1M0U6r5\nC1Qsy8O0LR4+fsz169cBgR9UWcwW7O7usrKywvqFDf7sz/+C7e0drl29TLffo1KpsH+wC6pGq95i\nsZhhazaZoVGrVuid9cnznChOKak+83DI81e2ee3zn2Q2GtKotygyaDXbKLXGeQMiRZFIDK9lkWJS\nqjfIVJ3CUKhXm1JHEcaUG2VqWn0Z2fuTj9B/KlToz2hkzwhelmWd71B0XZeB7HlOnKX0hwMGoyFx\nljIej3F9D90yQVEYjsfopvSJPvOYPotRXCwWnJ12GA7HCAFpmsts4/kcy7LI85yDgwM++OAD6vU6\njx49YnNzk3K5zJUrVzBti/bqKorQZKCIKFhrr4IoGPYHWJpFEofsPrpPNXD4yhde42c+9QlevnGd\nIkn4zrf/ivt376CpKpYhvauj4YT9gyN0U2MymRBHC0SeYlsG5cClvSIDXWaz2Xnh6vcGeLZDmsb0\nej2CIEBVQddVadFxLBzLBiGFO/WK/KBcu/oc49EEwzBZXV1j3B+ytb5GFEoq03QywrYMHNNCVXWE\n4DyZybKlclfX9R/rrFVVFl8hfpwo9NHi/azbFkLIi8hH/l58ZBwvshxNURESWSJzwxWFPM3Oi30c\nywtKlmTnz6kUMutdUFAIgYkqufhFQVoIZmnCME4ZpTlhoVEYFqnQWEQpmmaRCxUKZWmnGnN6ekIq\n5ARB+qML4iwnimMWiwWmaTJbjDk6ecLB4WP6oyHd4YTxdIbt+hwenaCbGl7Jpj/qMBwPUHWdXn+I\nUDMm0x5ZssBQTGazGZd3rtBubhH4PtpSgJYLgzxWWF1ZQwEW0zmnxyfM5jPSLCbNYzKREqYxo+GY\no+MzDk/OePp0n9e/+wbf/dO/RFENVNPmeNylejHDa83IsgivdpXV1/4r1NYvkiomj3d3mUdzUOVF\nyDBMFM1kNl8gcskMGA4G5HmBioZtuwTVGrNFxod3HtLpnFJyPRzdRMkzNtZWcSyTJAqpVquUy2V8\n3+MHP3yDwHFJkoh33nub7Z0tbt78JGsbW8xmCa2VNtVKjRdeehnb9dB1ncFgwGI2Z/fR4/Pwn6LI\nUQpBEi9IwhAdgRAZL750g3/1F/+Kx48fc3h8ysWLF5nNFty7+2B5ruRYlo4feGiqQRJmEiSUxpQ9\nl2a9web6KoUCr9z8BPVqjTxOiCIpYAzjiEpQIc9iRA7NapXFdMzp8R7PP3+FjQurvPXm96lVA6J4\nCuRYpkaWLQgCg52Lq+zsbGBZBYFTUA805qMOs1EXTc1or7ZwDAtTNzA0nVq1dZ4K53oOSVagKgZr\n6xfY2trilZdeRFNgPB6iFvIiHcULFuGERbxAKAJRJJi2S7lcJo4WrK7UaVRKGBrohrpkTOR4no9t\nWjimJaFDtoMqChRdw7IsNE2j2+9xdHREu91eUvik5W48HqMoqtSNqJzDfprtFVZabRqtNpZjy+Aa\nXZHxr7pCfzRkd2+PMIowbIvNzU2Ccgnf95eXKxln2xv02dzcJExTgmqFi5cvcfnaZS5fu4xharz0\n0gtcuXKJLMtAVajUqlTrNRRN4Zu/8Q2uXN+h2pDPaXs2O1cusbq6iuNY1Ot1dK0gjUNEKp0y4/GY\narVKFMUYBjiBxYWLazRWSpRKZTwvIChX8H0fz/PQNI0wDKlUKly8uMOlq1dprG1geB6m72MGLoVh\nYAVlFMvCdMo82TthNI0ZjMOfuHb+dHTgWY5lWXzpC19gsVgQeD6j0Yg4Tbh++QoXt7aYz+eoIqVW\nqaPrOsPRGE1VmEwmGJosLtPJQKJQhWA0GVFr1Oh0OtRqNZI45dq1axwcHMnc3XqVXq9HlskM5Fqj\nTpIkaLpOpVRFLWBjY4Msk+rmeBGSxolMQhqOaLVXqJRLNGpVKiWfyWhKo1HjU5+8ia4rhOGM9kqD\ner3JlUuXWKRj3vzR25i2x2w2IU0LxuN9Xnr5ZW688DFa9QqzsbzB+SULpQDfNHDMEmPLoNGsUagK\nWZLSaDQYdHrotvS6Fkm23D9LwMp0OsZzHIRdMI9jxvsHKIbBwdEhlVKZku+zf7DPFddlMByyiEJc\nR8bk1c0Slm6gKAW6rlIUOUIoKMuii6qi/n9dZCgFaOpH4Pz/Wvf9bHSuL/Pb//UirqkKuUgxVYNC\nU8jjHJEl6IojpxHLDjyOEwzTRCy7fVHI3WwuBBoqIpNWpkzkWI7Nb/47/x5xASvtNf7R//z36Q16\nGIWC7sr9PIogSWOKhTiPtQ1nc4KWR3exYDIZEc9nqGQouoptVkgcjWarRW/a5WzaYZFE1Oqr/ODN\nN6nXN7h67TqmLWi16jx58hRVlR3ReGQxmxa4XpvDcYhfNnnx+R327+1hVF7hxtfkOqwUFNimTm84\nJM2lw0HXdbzAQdVUCkUhTRPSLAeRM1uEaKnANwwWSYriOMznEc2VNYRpcLh/zKDTZfc7P+TaZ/4m\n7fUXcLa/zKz0HNcq/5LJ3hsYlTq5rpBmIa7nE6cJjmUzHg9xhIXruvRGY46OTlBsh0dPjiiV6+hm\nzsrqCr1Ol+m4D0VEEAQYloltu0RJTIHCIsy4dfs2v/Vb/wH/3X/731PxAz79+S+R5IAKeSrkmiJN\nSfOcw5MTRoMh08mE+XjMr37jK+imIS+mRU6j0UDkOZVGjVmYcdjpcP36JR4+2mWe5ti2xa//+q/x\nh//0j3Etl4cn9/nu69/mb3zlK3z/jR9hGQar7Q0QOY16E98rE+Y5ozjE9UxJzfMt1J5BrqjMFxHd\n7gGVoAxAmMQ0W2WiaYKmC25+4gZ3PnxM4Cj86M33uHRph1xXqFRdrl2+wPCsDxT4QY1Ws4rnW1iG\nRpYmbOw8R/Avv4WqKSjopHmI5XropoGuKay2V4hTOVEEyYE4PjvBsCws02QRR6iGjqlJRb0MJvLk\nKDvKsR2Xq+0WncGQS5cv8Ob7e8S5jkKOpls01tfZWG8zHI8oMEkSH103UXTl3E53enSMqmustNus\n6zpnnROS1KRcLYEGXqnM6ckZ9cDFch1azRVM22Ecpsw6fYKSxLbqlslgMGB9fR3LkKN7TdOo1+tY\nmorrB5JURoHjuWxvb1OrVWivr3D/3kPaa6vMZjO8wMXxbGaLKYOBPPfX1lapVCpEyQLDVMjyBSgJ\no+kA17NYhHOyLGGt3SJNY0SeIuKcRquN7/skyQG+7xHlKY5rswhlY9XtnXB4ckhg2lDIqadnGzIK\nN5S0wqBSZhHK97rtGgghyIoY1IJCzZiHM1zfoT8YMxhO0HSL8aTHtZ+wdv5UFPBcJKgalEoemgam\nraObKsUik7jOPGc2mdKsloiWKWDVcoXpbEIYhuR6jmYa2K5DmkoD/TM2cq1WYzabIfKcBw8eEARy\n13vt2jUWixmeJ9Wpvu9LRnZQljzs3kCyyZeJMX65RDib4zoOK80Grm3R65xSrngYukqex6ysrFBv\n1un2ThgMe3JfO40YDsdsrm+iqCZxmvGXf/VtXnjhBarVKisbaxi2wf7BU0xFo1HZBg1mswmuZhEt\n5C2tc3pEVqg4lsvDh/dRCxDLyYIfOCRJhKboxGGEY1kSjWnq+NUSgeejmBprWxvomoFpGGxeuUQk\nMoJ6FTsNMFU5pi2VSuhGhwLZ4YbhHMs08TQDiW0RyCm9ZE5rS5jLR7twRVFQBJLbzkc68o/4xz/a\npSuKgqEqIEAUCUJoCJGQ5xmWUpDlybmIKhcC8vxc/V6ATHGiQAUUTaZ+PevqTw8PSAuV06NTxoMx\nehxRtUyieI6lLH9uRZwT5PJcMJstCOf7LMIpG2ttJuM+Igu5cnWbbu+M3njAnYfvY5V0dq5sM+yN\nOet2MEyH+/cf8PyNq/R7A65c2WJn5yK6btLvjYlThzRNefOte6DDFz53g4OnuyjrX+PlL/w2AKVK\nit/OGSYhcRyh6hqFkuO4tgw8yQUUIApIogjPsdGEYN7rU221sU2LIhd0D0+4tL3DerXB7rsfgKKQ\n6Qp7j99gOj5g4+Jn8GsbUPuPcEovcHj399ncaqFXLbrHHVqrLXqDLhoK3UGfs16fXFGZRXNOD/aZ\nLXLqdZ1qtcy9Bw/IMgnJmc5C3FKJR0+e0m63WbMtVF3Ddk0ePt3j6pUr/PZ/+Lf5h//gf+MH79xm\nXlhoqs6kd8p6u8nxWY9apcL+7hMmkwllz+cTL3+Zq5cu8PCJZLWHYYhtWgyHQ46OT2murKAYCrph\n0el0WPSnHJ/sY2mCPCt4++13ee6abAIeP93DCyr4QZlC6IymQ06PzriwcUkKOpOYMBxy2D9j+/Il\n9s4MFN0hTuc0mzpHuykJkIiEq89dRUkbxNEc13X53Odeob1axnMNRuMZJ90eV3/p59jaWmF0csjm\n9gVs0yJOE6zCIUzBNS1msz4ba3KsimKgaDGm6xPUJEHQdEwubK1TKHK0broWF7Yu0OvJzHRRpHQ6\nHaJowcrKCoic/nBArdVkFgqG/T5erczG5jqKVpBmEa5TJVcEu50u9a11omEHG4fCBQufIheSBz4a\nMVvM8atl2q5Hb9znwto6pm2wWmpzeHYiO+QoRbcdvHKNLFnIqF5Fw9At2qvrJElGvV6j2+0i0gzH\ntNjY2DifalmWhWuvoGkaji2FbEVRUKmWmE9nqKpKu91G05TzaaS+XB2aprwsLsIZ/UGftY0VhEhI\nI0G9XmE6XZwzDTzPYzoeIkRGFC2o1NoMOn0ywPd9BoMRtm6hqAWKZjKdRYymC0DF1C0UxWA6mxHH\nIYamk2aCXMDB8QlBUGYymyFQKJcDBoMBRZHjOB5xmJBEOUkY4dsmvdNj1tfXf+La+VMxQlcLIJfi\np/l8jmEY5/+XpTGOaeDZHr4bkEYJ5ILRcIBSQLVcOR+3rqysYC2xkJP5nEUsx8y+7+P5Pv1BjwLB\nx56/jihysjyl0awvOcl7zGchg8GAu3fvUqlUODqS3fpoNGI8HpPkGWdnp1Kc0elweLhLr989x33u\n7h/w9lvv8PjxY866Hd59/xb94YjX3/gu/+yf/zFxHPPw4UPq9TqdTofBYMD3v/89/vc/+APeeecd\nfNelyAXzxZSCVOZ9pzm9XofDw32mUwlikQjSHsPhkFarRa/XYT6f0+t3ODs5IYlC4lBi/46Pj+kP\nBzx8/Ig4Tej1u5yenrC+eYFHTx4ymc8QCtTrVcbjIYNhj3LZQ1eXgSOKgqrKqFMhsnOxWrF8vc5t\nZMux+kdH5Iji/E+RC+lxXYI5nj32o68zSkFWSIyhpmkoakFR5BLiUuQUCiiaTr582LP9U5Zl6IqG\nYZnEeYZumSgF5EnIt//8T/jen/+f/N7/8g/QC43ZLJJs8SKnEBkiTylyQZJE56AP6QfNaDWacjxf\npJz1j0FJeLp7j0Ucsbl1CUW1iZIc2/VotlfxgjKVUokH9+6jaRrj0ZT79x8QRyn7+/vEUYdmw0UX\nCc9fvkjvZIrY+i0uf+G3oSjY3DaotQuiKCJJEgoKijQDpZB4xwIUNJmeFUcURS4jWBWFTq/LPAop\n+R6YOicHhwhATKbkimDS66OoCrlSINSIt37wT+ifvYfIU6zNz1D94v/AUP8Y4/EENOh2u0ynU1KR\n0xmMcYIKaS5QTR3HtdneaqGoMbt7jwnjiFKtQipy5nFGtzNAU1Q8y+KD997jRz94g5dffIFbH9xh\nMhyxudriH/5Pf4+S6/Do0SNcz2bY3efJ/dscHuySZQlZIRgMBrRaLXZ2tjk7PsKyZWdTr9eZzRdU\na3Us1+Xk5ARRpFza2abdbgOwsbHGanuFixcvURQQBGX+k//0P+MHb73Hgyd7HJ/1ZAc1k1a0ux/e\no16vY+sa2+tNXDtDU+a89PLHqNZaCODSpTU8xwZFwmEEObVmDc9z8DwbPzAJAguRCpIkk1ZE18LU\nod2q06iXqVcrBKUKQtVwS2Uc3yMMF2hKJldhmkWBQKBSrZbxSx5CZHglG0XNqdYCLMtgOB5hmgae\n51KpVllpt9nauki9XgdV4+LFSzIi1XawPJ8oSynVqly7dm35PAqaAnsHR6AbKJpKUPLwfJf22gbr\nFzZJ84x6s0G12SARBYph8sLHX6HWWsGvVCk1m2xu71CqVfErZdpr67h+gG47VOsNXD8gL4REyS4D\ncjzPw/c8onBOlqRsb25R5HL68oyep6hS5+MH7jl1MgzDc/xus1mn1+swmUwk1W4phC2XAzY21mg2\n6ziujaEpJNGCIktxLIMkTJhP5iRxRhjGxHGKbtsYtkSbGra5FODK8811SsSRIElUssTA0CRqej4N\nmU5ijk/6uF6Z8WRBITTiBLJcpXMyYu/JGceHQ95/9xEiNckzkzxWyROF8WBO2a9D/pP3zz8VHbii\nKOcHu23b5we8PDzl7vPO++9jGyp5GgMFmmmcj1Xn8wWlUoBlKLiuzWLJ2JZjMF+ylEslfN8lz1M8\n18T3XYZDj06nQxzHtFbamLaM5xv0R5Lb7Hr0el0M02I6mxEuFmi5oNMdoBkqiyQmLWTH7zgeT5/s\nSdBKJkeeIld48+1bOK7F6uoqt96/zWg6w7JdDEPh8eM9CkMhCMr0e0N++MabfOITN6m0Sui6Spqm\naKhcunQJPIujkx6lkvQxjsdj/KDEhx9+iOPqqJrUEgy6vfMu/FqzSbSYM5+aKAo4lomS5+iqyuDs\nBN9x0CkIPJsCmSUuRWnKUpCmYRgOuiEfp6gqipCBJc866h8Trn30NV3+efb1rFv+6GsOnKvWLQ3y\nJEczDDDlJCFNU0whUBR5y9Y0jTTLzhXsi8VCcrNVjTRO6HQ6WJbDyckJhqKw0q6yXnFxLItoOmU2\nnzKYhqhCxYl8KOROVdOFVFsvueD1lRZKkTMPF8zmCe+8/x4/97Ofoj8asLLSRJ05LKYjJuM5rh9g\n2y6n+/tMo5xWo8Yihuksoj+YMpnG9LrHuF6JJMoJp3OqFRdN16l//D9n/eprQMHOdYtJ0oVJTrRY\nILRCCmqiBN00pBdbFSBAVSBNUnKRE/gatmEyHY6YTKe0mw2p6j3tMp2OObn3iI0b11noKmqWIbKE\nMArx62X2D97Fik6xqjcwShsYl7+JaN6kdPCHnO3ep95cIS8yTru7lEqCJEuJ45Qg8Gi2StiTnDSb\nE0aC2WSGik4apXSmEwwyqtevsHnzZT68c5ebL7/K66+/jaIUlEsu4XTIr/zSz/PG+3cJXIvnrmww\nTwUfK61w68ETdvf2MFybl26+TJoMCSplqlbAnbv3OOt0aTQaWLaJqsDx0SmKKSj5zeUBDH/x53/G\nSqVOUL2AAty794B333sfN6jw9lvvsdJe5eLOBqYT0j+b0F5dx3YdTF3lxY9dRdmsEdTrjHOPv3rj\nQ7od2N7eJhVvAAJNUXAdhzSaUq03AHBMj0qlJAN+NINsCStaXV2lGVQYTWRqm6mqzOMEspQMQaPZ\nYm1zE9eyWcxzUJXlWWiSLSIMBbI8pVwOyDKBY9l0s74UqhmyKx8OBqRpjOd5qKrKbDaTXaqq4toW\nui6V+7Vmg1KpQmcwx9N10iije9plreTTOz0ijOcUuUMl8BgMp2xslLEdk51L0skzGE9Ybbex/TL1\neoskP17+/mKZHT+h3mzgBS6z2YJS2ZWrPaVgMplIpK0tYT55nrOIQkxb5gXYtonnlcnzdMkDYJm7\n8Nertn6/f/47PjujdN08v3yDYDadMp/Lrj03BXGcMJ8mFEJhLCQdslSWl4Enjx9RxAoqGv1OjzRN\ncQOTnAyimMF4wps/uE3FcTDSjMk4Yjqf0V5bJY4ijg4HpGlKtWpy1jljPJnR7Q5xHIdBf4QQgqdP\nuhQiYzYZLPkcGkms0JmPf+La+VNRwHXVYJFFFIVCnhdYlnMupEqSBNXQUXQN27VJYkiSmPF0Qhon\nqKpKuVyRh71usFgsaLfb1Bst0kSyZsMwxPVsxsMBm5sbaKocDauqSrfbZXV1nclkQm8w4vrzNzg5\nO2M8HlNyHUzTJMtz8jyXOEfPYzyaYdoGlueDXvDo0SFJPMYyLMrlMqpWQlN1slRlHmccn+xToEvq\nmZCs5e2tNRaLkO54wFnUZ6fd5MqVqyRRyuHePpZrYaKipQmi18MSPpqmYbseqDmuZWGYlrzRBhZp\nFuPaDpWgRJHKcXPg2Fy6uIVrO5QqVanq1AxswyQK5zx/+TJROEVTQFMLGs0qRsnl+Ej6LIVQETlk\nGZiKQpamqJouP0zLov3sg6Wq6rnNC+TBdR6ssfy3ZwjLZ933uUpdUSDPUTTJM3/2ffOsIA4TemMZ\nSvF0d5eV1Q0ePXrEpUsX2d/fp9VqoS8V971Ol5V16Y1VCyCLMJQEsyjQREJRaAxnC0qeT5EqGL5F\nliUoSn4+bVAUyDL5vppMJlza2eT5F26gaBqjyQDfcxEzEMjwjyzXqFba3L79mMvPXWM87LO+vsrh\n4SFhLNi8sE0YyQtLOOzz6PEDmttXuPILv4tT3kHXCtauKvTjU6IsQ0kzySBwbY7OjvFtHwN5OcpT\nqY6P45hzYo6mLn9/jeOjI1bqdWqtJif9x5wenUIuIBdYtkWUpmRqQTifk+sqvmETigVq/02mxx9Q\n3XkNtbxNrn4T8/B/JE9yhpMJQqg8ePgUlgTArZ11/MBkEWVcubTNO+/sEdgu08WcNE3xHZdv/PLX\n+czNlxkN+nzy5Zf5/pvv06yXefjoPht1nUn3CLt+gcCyKPkO21trzBPBQW/On/3Z/0130Mdzq1Sq\nVQ6PztBTk7PBMa7nMZ3NCRdzXMtYgkAChtMeZ2dnJGGCEPCNf+ubkGT83j/5YwlOKQp+93f/MUEl\noL22welpB8fVuXJ1izsf/BmDYUgwLeE7Np946UX6u+9w7fkX+Pv/6x9y794t1AKSULDSri0nfyUM\nTSdZSFul43iYlkeBhm0bKLp8b5+eHuP7HuPJAl0xKHQF8pTA1kE3KJUCdNfB8kromkKeCizdYDwY\nU2+4ZMC010dgUegy5cq2bcqBj22b6FpBtJjT73bQNA3fd/F9mYdu6gZZmOLaFqomrWWDwYg4TnFd\nj2kUksSCwWSCq2Qohk41aFCoAZP5HL9UJRMKQhQMJyO2trYQQjCLYrJCxa9UUAc9dNNkMOwQVAI8\nz8INSqiGjmEbVLUy8/mcXKQEQSCFsJoUqQLEcUy5XCbLMkxTZzabADAaDRAik9CfeIGKQpKm+L5P\nr98hiiIMw1h6wjWyTJDncyaTAZVqiZJfotvtkoQZURQRlGukiWDYH5LmKZ7nECcRe4+fYCkOvu8D\nsqFIllbZKB6S5wVv/vBtdtYvsPvBkMFQXtof3t+nXC7juBZ7e3vsHxyg6BbhIuLJwS5bW9s4tofv\n+7z97i0Cz+bB/Tt85UtfIEkSXnrpJe7evcNXf9La+RM+/t/I12g+ZjwccnZ6vPR3zonjEBDnWcUH\nBwecUKBSLEerBbquLFXmGb1eH5o1DFVhOB5SKVfxvSrkgorvc3BwQKlU4733PuDy5cu0Vtrs7h5S\nq0kedK3eIIxT9vaecnB0hqYUHO4+odlu43oeaZIQRxHT4ZBGfYUCwWwyRSiZ3A2rGpMo4cMHj5nN\n5c0rjDIu7VxGMz1EoZEXAsvWSNKCB48e0aw3SJME09Q5PRnwwN/nSz/7M+hakzBNyNMQ3zUYzTR5\nmFUccpFAYYCZk6U5k+kYTS+jIMhVeXPVFBXPC0jiGRQZqgEij5lOxiiKglOts4hCbE9F13UmkyGN\n6jYjBEWeYZsmhilTruI0RXdd0kSOnFMhLWS5yFEVGSv6LEb0WdHWkCI1lr5vnhXkjxTuj+6/VZbd\nugKWplFooFomaCpC1wmXXWiS5+SFQDdNilxgWyZFoZCJjLzIKZfL6GhQqKSqQBQ6kepgmgYRBoVi\nslgsGM9dhl6IV2RkeYQm31XkKiRLFa1qLHj+45vcunULS9c5Pj2jXKqwu3/CcTcmI2H9wgZ7u0e8\n+853qdVKbG+u8SCaMZ9NqTbqiLjg6KxDZzYinyxoeD7XP/l11j/7X2B7DVQjo7ad8+jJEwxVod5o\n0F3MuHRhi3t7j6hVyiiKRhjHeJ5LPA+ZRtInXKQ5SZ4xM2YMhkM0UyNPEt747usYtskLn36VR/fu\nEVza4OjJU1THRDMNtCRncXjIxsdvsLK2wYcffsBqrYxPzMM3/hFXX/u7FMFF+rHO4PFtUqEyjCIm\niwW6poJi0T+aIBY5e3s9THdMQsE4mqCYGrMRfPWXvsC/+7e+yeN3X2ejqpFFPX7+C59hlKb80z/8\nI1584Tm+8Zu/xe/9sz9hQY7mefQWOoVqcHTWQckCzHzBf/x3/jaWkfCxy1exLIv9kw6T6ZxyucJ8\nOmM2Wyw7WoV6uYVh2uRKSmpANJpz5YUdfvGLn+dPv/06q60qv/Nf/l10s8l//Tv/Da5R8O//rV8j\nHR0SZBOaFy7zeH/Aw8Mz1rbb6MoOw/GAnY1NSo7NPCy4dfsOniv9u/M4IahXiZUFpqYwm49RdZPZ\nJEaIXEZLopLkOnalRvfoFNuz0DUTyzFBKUgXGWGa0vJdSBJUXcNwNOxc56RzQmt1h/6kh+M7OIHP\nbLbAdg2yLKbZqnHW7aDnOo2VKpsX18mzAl03iaKI6XTK4yeP0J0y5VLApNNl6+ImN2++wl/81Tt0\nxwmOaTJKMopcpb62SjoeEzgmqh8wnI1YUeX5GscxfrDB2dkZjuchipid57YplJQr17YpioI19wKa\nrmPYgkIRZJm055ZLPlG0IMsSBoPOeRCN5wVMF3Mcz2M4lNOEdPkYIQRb25tMp1Om06lcOc67eIF/\nvsJrNpvLkbv8THe7fVRVRddVTo9PMAwd3/exdJ1kUcgQoEJF1TXOjo8kAKdSodneIhxNqdUaKLqG\nYRuUyh6T8Uy6oAwYz+Z89rWb3H/7LZ678QKu53P37n3eef9HXH/uedylHe5Tn/0M9+7d4+e/+hoK\nGnt7e1imWFImyAAAIABJREFUzSsfv0bgu/zqL3+FTqfDhQsXOD095YUXb/zEtfOnYgdeqlep1Gus\ntNs0Wy3KtSoYGpppECcCVbOYTBdMw5gwyUnSguFkznAYc9adcXQ6AMVkMJgxGC2YzVPee+d9Oien\nvPfuOxwfH5MlMYPBgCzLuPvhPRzH4+bNmzJ1S1GWdClZBNZW2kxGY7a2trB0g1qpTLNWZ729ytWr\nlwnjBXEc06g28BxPFg5dJY0TiYAtVJqNVRzLYTKZEEUhw0GP8XBEKuTBa9sWru/imAaKKAiCMmme\nc+vuHR48fcgsDhGa9Ezrpin52/P5MpxBldnZjkWrvYLjOKBoqKZDuVpHs2wMx0bXLaIwJ5pnpLFO\no9HEMl3OunJ3fnzaYbGIaDTbLMKENIFBf4qlGTIOTwgKRZHYVOWvwSuw3HU/K8aaJLBleU4uBKnI\nl4Iw+WHMkQz0Z8X72Z782f4cIC8EaZ6RIciKglQIkjRbqtmlgCRPUgxdRVdVoiRFKJqUrikqWS7Q\nTYsojkFkZHGGyGVspG1YaLops+MLhUxo5IpKrkCOQpxCpprkGOimRbkWUKra7B0+5OzsjL3DA45P\nThkMp/T6M8JoTq875kdv3iGOQy5sNkiSCNOUO7vHD0/oTSacnZ1Jm0mU0GquUt75Cps/+/ewvQZB\nWaG6FTKZDTg7PmZra4v5fEatXmMSz3jnr15nc2OTo4NDptMpiILZZMpoPKY/GCByqbQul8sYqko6\nD9FFQb1aJZpMGHZ7tKpVNFvGjOqFgmoaZGEMlsGNT9/k6PSINEk4OO0QKRroFvl4F4DG81+j2ayx\n2m4wm02Xlk6D6zeexytXmcU5pWaNVDUwTYskyjALg5Kv8vp3/5JvffsvWd3cJFcNNK+E6Vn87Gc/\nTaUS8Mf/11+CXSMpjCXHQMGpNDC9Cnc+fMTZ2Rkvvfg8Nz52Ccc1cV0b1bTOBUumaXBh6wL90ZDJ\nbMoonSF0afXSUCCFaDpm/8Eddi5vkRfwses3+KWv/QJ/82s/R73moqHQXKmxsrLCzZsv8os//3N4\nlkepHJDEBXu7p0TzBNM0sB2LXAg2NrZI0hAVGI1GmKbNysoKmqFTqVQwNI1KcwXL1BFphqFbnA4G\npGmGoqrn4SrDyZTZdH4+Ki+QUalxFp/bLYeTuSyeyYIonKIqCoahYVoaosgZDAbouo5pmjIoKEqJ\n45hut0u5XMa2TcrlMgUZjmOxs9QHtFotmUEeRQhJQ+bJ0wNJo0yl+DOMJUK3VPZR1IKVdhPLsggC\nH8e10Q1N/iymeW4bC8NQoncdBwXZEZumznQqLb2u6+J5HnEiNShCETiOTC+bLqZopqQ3WpbFeDw+\nf0wuMsJoges7JFmMbmrUGw22Lm4iKJiHCxm8Uy4TJwmmbbG2sY7ryzG75TqYtowhnofz5eVBKvSD\nIFjaQueMx2Mq5RpBEJCEKeE8pFIpoys6h3uH9HpnDAYjbt++zXDU4b3b7+L4NuW6T3/c5eKVLXIR\n8alPv8LVKzs4joahK3KqqSu4nkWnc0wYTun3z1BVwWDQ+Ylr509FAQ/DkDCOOOt16ff7jCZj4jRn\nNg9JkpzJNKQ/nNIfTDg+7XLc6XFwdMo0zOn2JwxHC9AtFlFMLhREobPeXscybK5evsLmxjqNZo16\ntcK1a9cwLJNbH3zA0909BoMBq2trNJtyj7W1tUW1WpWsZ1XFdz2yJOX48Ignjx5Ta8hwkNlsxocf\n3OPxoz103TxPYsqzgihKmUymUMgxbKvRIAgCOX6azUizjDhL6fV6khGu6vQHA57sPmU4HrN3dMgf\n/cm/4E//4v/Bdf1zpXwYyii6OIkQ5Oi6ynw+JYwTdN0kTXP8UhmBLKoiV0mSjMFgxN7eHoP+hMUi\n4ujohPF0Tr8/5KzTYzqZs1hExFHKZDKj5LvoakGahiR5RJr/dezdufp7WYTTXOoV8kKc0+wAFF0K\nS8RySv7Xgjj1HLn60e8pVAXFlKsSoSrkFKQIckWhEBBHCZZhoi3XKo7jkAmWaWcCVTc57XTIKQjD\nELHs9qfjKaenHWazGYWm4pR8ojgljGI6gzG94ZzxPGYwDHn4aJ/JLMKwDWkdOdxn5/IlXN+n3mpS\nbTSpt9ZZXWtRCQIuXdygXitTq7hEUcL3vvsd1tfW+PXf+BXKpSqGY/Pg7gPGnSne5lf52Nd+B8N0\nqTdUtMaQquvx9MEjPMdBNU3QNFzH4offeZ1oIAv1SfeMJEvRFY2S76MoKt2zDo5tY5kWqqbSPTpB\nTTLi2YJpf4jjuBw+ecLh413iRYjMhc9RNZ18tuDlL79G4elMwhnkgjQvGM1i0G26++8CYF/4GSZx\nyP7pLjdevM7V69d49TOfYh4u0D2LYTSnO52T6RZhrCEyh2ihYTsmaZ6zyDTCwkKvtNFLK1hBQKNU\n42c/+3nuPXjKO+/foygUGqUKp3uHBNUGp50+3W6fLEv45q99nVq9DAjCNGMwHoEqVcnd3hlPnj5i\n++IGUTLHLzkMxj3m0xkrzRaaZjDsn/ArX/8KX/zqa2TklOpVLlzfwa+YVJolFlnGIktwK1UubG2w\nutbk4uZF8jAkHE8xNYeLFy/RbNZBSVAVBdPyEHmMaeiEccYHH3yAbVoYhixkqoqkkTkWiII0S1kk\nKYbrgyYjRJ+JLqVgN6QgJ45DKpUAy5KCLIHK937wLp5bpl5roKqqzEZXFEaDodSHJDlxJIunoVv4\nvk+z2aRcDkjTGMMwqFRLrK21aa82MExtWYQDXNfFD9xlHLDCd7/3AyazCaVqCUWVKzLXtVEVk0Jo\nGLqDqpgkcU4aZugYDAYDokiO85+tysbj8TK/Xj0XsuqGJj2mSiHT/JKE6WLGeDxiNBlRb9bxSwGK\npoIoiBYhKgrhfPHsYUzHEwmucm1ykZGkMcOhVJKDdJAoukazvSJhT5G0MlqOLQlsmnruTPI8l2az\nQZYlgFjCVITkiwwGCCEYjUb4vi8FnpbLYh6xCCdsbm6yvb2N5cDLn3iBi5c3+eKXv8Df+PrXuPnq\nx3nu+lXqjTKL6YSLmxd49ZMfp1L28AObRqNCvVFFFBnDUZ+LO1ug/Dg/4//P109FATctSzKMDRPD\nMM7VhoquoZs25XJlGRupoeoGiio/DEVRUKlUGE76JFmIbukoesFZ55hCZMznU5Ik4s7t98/FD5PJ\n5JzG5ro+umFy7/6HBCUP05R+8nK5LIUSKERRxMnJCbVqlWajwTvv3SLJxLJoK3hesCxOBWkaS2Re\nnNE5GwDqubdYV+QNXFGUc0FWGIZYloFtyefVDP2cM215PnGSceu9989vuedj50Lut4oixzJ0DE2n\nVJKjvTAMlzngBoqaU6m6NJolNrcbBIHH+vrq/8vcm8RYlt1nfr9z53vf/GIecoicKmsgi1WcRFIU\nRTalpqTW1HJblmUDXnlrGF7Y8MIbb+yF0TDslW3AC8NouAF3y5BboihKapEsscjiUEXWmJVjZMb4\n5nfn4ZzjxXkRRW+bm3pAIhCRmS9fRrx7zznf//t+H69++iV83+XuC89x89YBQegRtVzWNzsc3NrD\nEg3Q4AY2ihotNJZwcFY3oItf5jTkYbkO9up7J2zLFLGsLqoLufwCOXjx2oIgwPf9y6/ZGjxhI5TG\nFSZrbkltala1IAxDitxECOM4JisqwOA0bdcnzQt6gyHD4ZCrB9dZX19HK4OFqaVECSjKjEbVKzCL\nJC9qylqRV1BUmslsiZKaPC/Z2NoCe7XZwObx4RN+/s7bHJ0cE4Zmppgs5wx6HdY3Ojx/d5c0WXLl\nyhUePjukKUrswGNtbZ3f+OP/jk/+5n+JZdls7kJ/u+Ts+JSqqXl8+JjB2gBHC1pRyAfvv8+TN9/h\n6gt3yPKczqCPqiXD4ZC33/o5+WJJmeccHR2ZyFORcX5yigAcz6GRNVVVEnU6TMdjBu0uotE0UlHM\nF3T2tvF8j6cPHtPr9kzJj+eR1wrlBtSqJJ0/w/HbRDe+StTvM54vODk75cnTQ6TWxIulmTVriyQt\naXW6CM8HN2CRegzWDvjCF7+MJSRZtmQ6nXL47Iyq0bTaXUpZ8z/8j/+c9a1NfNdGVZIsy/n5z3/O\nkyePWFvvo2TF62+8zuHxCc+ORhwfnWNbPkqC73pEQYjveqA0XT/k7tUrPP/cDt2hj6Thxc98it/+\nZ3/IJ144wAZUlUOeMZ2N8AOXojFxQVVrer0OWjWgBJ7n0Om0aLWMXKt0g+87xvHfNMTJHNk01BL8\nICTLEzzPM/Ndy0bYDiiJ5djYlsP5dEqV5Pi+T5IuUdqAicwpuFyZOGs63RZbG2uGDNho/vpvX+PR\nk2M8v0UUDagrRZFXZoPd7RFFbdbXN0GbxfJiUwBmrhyGIYPBgE6ndcldMKd27/I+0pQVAEXe4Ech\njmc23LKpsBH4boBjuYbYJwRh2MJxPHq9AZ5j0ZQVrVbLkCzbbdqtFmWRUVfV5Un6QuGMouiyHnZn\na8tEdqMWs9mMbrdD0xgFIcsy2u222XCvDkWe51GUBrrlOI4Bb6nmcjOyWMywLKiKjItF+WIDoZSi\n3TVd8Ovr68Yw67toJCenRzx+/JDT01NaLdN7DiZO5jnupeq5t7/Dc3dvce3aNW7ePMC2NVtbG+zt\n7XDvw/cZT87RWtLrdaiqiixPmC+m2AimozEbwzWaqiJJYg4OrhNFIaenJzz//N1feu38WCzgruMg\nNHQ7Hfq9HqEf4QiLIAgpiuKSyFbXNVVlbtxpXpBnJVJBmhQURUWSZAgh6HQ6HB8/A22ckQcHB+zv\nmAalujbdu8Ph0MzF2x329vaMI3IVGTs8PEQpxf6+MUTduHGDW7dvEwQBcZKyiBOKpgbH5ez0nDTN\nsG3XOKJXsYZOp2NcpE3D0bNjktzI7sPhkCv7+xwcHLC9uYVSirI0TswsLSiKmvPTsUlfCYsf/eBH\nJKm5CXbbPaqixLUdtFI0dU0Sx6aruiyQdUVdFqwPB6aRDJeyLCnLEsexePToKQ8ePCKOYx4/fsZy\nkXJ2OuJnb7/Le+9/wP0Hj5hMJniBj7YEjmfexBcXHliX0viFPK61RiiNbqSpHV09Lv4MmBN20zSX\nr+WiN/yiK1xKidUoqBp0WWM3GltqqBqoGk5OTkjTlOXS7MQ3NjbQjWR7exM/MtlqlGZvZ/cj2V5A\n3YAUDsqycVabRN9yKJuGogFt+Uhs8lqicHC9CC8wm4r5PEFVFifHZybpkJjO+usHV2i0oijTy+SE\ngQUN6PXbjM7OKWTNYjYny3M+8ZX/lGuv/jFaSbb2G6biGaUvePuHP2I8OicrMtaGQwRwdnzCz3/0\nEwB2r1+j5QUcv/8h+TKmUZLzZ0cUi4SXnn+Bs/NztNSMT8foosJqFE1lbrxIRZXlRH5INlvSbrfQ\nVY3wPMJhjze+9W/pKIdhp0ur3cbxfaQFpdYUSnD8+E0Adl76A2plUxU1vuuzu7lFOwrM98jzaOoK\nVzXE58+QyQhHTuhHDj1X8N//N/817/3kDcbHRywXOctCkWnF8596ke6gxVvvvsN3v/8PeFGLZZ7z\nwTsf8uTJE06On/ArX/iMAXv4Ib4f4XsBg94GeZpTFgW9Th8LQZlm5IuYbtjixrVdfu3LL3JwsAZa\nc3D1OsKKsOocX8NiNGJydIQua3zLAS1IxjM6YYArNI5j8+z4CK/l44QOniOQtTGGaiQayWg04rnn\nbhP5LmJFHQvDELVKMNRVwWy+NJspxzFwqTgmm8/RdYXrOob86NhsrK/R6bRQjSRLEt57+z0soSlX\ndbRPjpacnI5pd/q4fkQUdgnCNntX9nFcl17PqITttmnPuxhFhWG4MoR5FLm5V45GI2p5ce+EOE5X\nTAdjLH1yeITUDWWVYWMThj5K1khV0siMNFuwXEzotE1tcVWmBF5o0ijmAr+kJJpTeI4jLAOE0lDm\nBWmc0Ot0jTmsKCiyzEjcrsdyvqAdtVYzbIeqqtjc3GQ6nV4SIFUj0VKZeKuwqIqSMAhwHQtbWNDU\ntMKIVhhRFsVKBTAbgNl0wZMnT5jPJlhCYwlNr9PGc2xsoanKnPl8ihf4l5uELMtoKlPfPJ+bPHdV\nFUwnI5SW7O/uUeYFWRIT+h7tdpvlfEq3HXH79m22t7dxPZvrB1fZ3tlkb29v9Z72Lwl7F0a+X+bx\nsTCx6UYS+QE/e/MtOlGLx8fHZGWBsGwcR6O1wvMdkrhEaLODakchTSPREjY3t1nMEwQSVVdsrq2x\ntTHAC1yTJ2x3ieOYyXSC7XqkWUan32M6mWNbCscVTCYj9vf3WV/f5J23PwDgfDTGdd3VvMtbLbaS\n+TKhrEpOz87oD7pYv5Bbv1i4hDBZxouTZqUEUadLnObM50u6rbYZHaxO4VVV0G53KeIMHQbMkhJP\n1Pz65z+PZcUrhcInjQs820Wq0qgAjSQKPFRT4FjGDZ7GC05PT/nUJz+N67RwhIWS5tRs2y62E9DU\nphgD26KVFniujR2GhFGHoN3D8SOaZEEl1eUO3/jRtEE3XmTC1EdxMNBYlg36o8axC7lc/cLnFwv6\nxeeWZXCmcuWsvgDASC2xbYuDg2tUVcXzL5h2q93dXePEzrhEu2q9midqSVrk9PUAZTkkVUNpVVRK\nUxc1aE1eN2AH1MImLWs8L6ABmhWrvS5ybO2QpgX7e9tUVcXW1gaL+ZJluqSuBVG3g+d2mMUpoOn2\nezjnPh98+AFeu8Vzz99lkSbocB+Aza2SWX6GbHkkRc7s8VNGJ6dQN/TaPZIsJV0sqWYx4c4Gd27e\n4o0f/AA1mtN7/kWSNMWybEZPj9i7doXd/T3GkzFNWaGrBrcTUMkGrTEnTqVpqooqW3EVpMZp+SxG\nY3SS0+m0SZKUPMsobUHoeuB7xEXJWkch64Kgd5X+zvP4R+9yenrKcnKCpSqm02cM+13KRNIPBb//\ne/+Yyegcx3P5+te/xjKpaLIZ7faQ9voes7ihqkpUkdCKXPqBx+bwGmfHZxydnBH5AUlW8vTpU2oF\nn/rUJzgfnfLgww+Jwi6O56BlQbcTcXr2DMeC5+/cIJnPuLL5JQbbG3z65RdptTWvvfEmloZkMoWF\n4TeEoUe8WBAvFuSFphUFCDRFtiCOz9CYzeTR6RG12zCenGLZCks4xHGK6/hARp7nHBzcpD/oMj+d\ncHx8TPSlTzCezKjKDEcLbMuhHUaUfoCVLimynCbNKZOUUlWEfkQcL5F1gZAWsqqoCsWwP2B0OsK1\nHZZlCjb87Oc/5+UXryK1wvVDLEuRl/rykNBut6mbj3DQy+WSfr+/cmWv4pZaoGqF7bkMBj0mSwOG\nqusaW1jYAqbjGUdHR7RsQV3WZGWM9AIStTDcc8vBtmwsDb7j4iDMIioV88nUgJzqBs9x2BgOODk5\noxe1GQ4GZElCFISkaUqeZmipiZMlw3VzKtVao6XZxFx4HIqiIM9zPM8Y1CzLIvRDfN/DFhZpUdIK\nIyajEZ7n0+/2mExH+KFx4C/ihVE4KtNi2OsOVpn/hGF/QJYlRC2PtWEP2wr5zKuv8MHoTWZTwwbo\ndjroWpIWDVI19HrmpC/ayrwvAgvHEty9c5uyLJFSoRyF1zUKbxD42HbE1atX8X3fcCocmyQxm5M0\njbly5QpV9dFo8t/18bFYwIUGx7Z5+62f0eu2WeYVwnUZDAamPlNYaGkc6e0ooMhyer0edS3J8jmd\nbosbN66xWE4o0jmako2tfRPzqCqmeXEpXZfS9EjXRYnvefT7bVzXYrg+oN3pcH5+Tl3XBEFwuRvb\n2tnm9ddfRwhB0VhInVFL0wMrZY3SGtf1kcJIYkEQMF9MiVq7pGmKbbto26HIS6q6QdUNk9GYKIpw\nPNfIw6UEpXGEg1ZGuvHbIXs7u1TlI/N6lqmZ7bg+CIuyrNlYW8cSmqIsODg44OzsnMV8yd7OLlk+\nx/dtPNvD0jbXD3YoyxKlJS+8eJtFMsFzA+48d0BTVQihuH98Sm33QNsI28fWDVVV49o2FqCFwNJi\n1RxmmVwjq/n/ai5u8VG87Bc/XjDNP2KpfzQr045FrU2GVwtNLRSFluAZg9Dx8fHKVLeSzW0bLWsc\nxzwHUl3S6SzLohGmgGSyTBAqZ5lIg2G1XPyWR60tyqohKTIGYQiOheU5KGEY73lS0mn3cG2HuIwp\ni4Z+bx3bFjw9WeB7gvPRjG63jeMKGixs32dnZwvb8Xl8cmZGA77Jz65ttjn84ENC3cJSDmKRsUhi\nAi+kE7WRixn5MkEuU4bXr9IeDjg8fIytDc++KAtUXeNqwTtvv82dT7zIYrFguVggHJtGSrRtoeSK\nJm9bKMB2DKXODjzqosRWDdgWOvI4OT0xpL/ApSwbHMum3ekxihPWFg9pr7/A9t1v8NoP/h9k3eDb\nPTZ3hty5/gVu3rzJc7du03Zd7t68xng25r0PP+DO7dssMokXuMySOalwkY5NdnpGrSW9wOHG3i5h\na8jrb72Lazk0Tc7r3/8Jizhhe7tHXqTMJgmtsE3gB4zOJ4Qti/2NXaBHXRfcurmDq7fJUsNx9yno\nBxtMzxcIbfHkyQNm8Tk/e/cdGg25asiKgnZnnaoxPQvzdEYt1kjKBC9PGI3OuPniXRxZMx6fs7O+\niWP7uK4PwHy25NqVTTqtCJiQpilnxwb2FAYusqiYz2eEgY9Kzfs+SXKy+RLPsyhrZbrsVUNZShzt\nIgDXdpCVpMwLpLTxXJfhWpebtw6wbQvLEQR+hO0pGm0WveVyTm/QJctSqtKoh+fn55enb8PBEFjC\n4cqVK5ycHuK6Lq2WUaI8z0OrBtv2cSxBWeWgcvQyY323v5KPa0I/pKnVqpK3REqNGwVm9CIsZK1I\nElPtWtUFw+GQ/d09Ex1rXE5OTlhfXzfIZw1RZGbvrm1O4r7vG0VRKhMZ/oWmOSnl5YIetAPyPKdp\nmsue+na7zWg0NiZiYRF4RuEI/eAyZjYYDGhqhe+a7oHYXhBFAYePHnP79i0z9lipcxcpmcFgwPnJ\nKZYwo1HHten3++TnS6IoJOq3UbXDZDIhDFr0OoZYZyEIAw/bsSjLislkfGn0G43O8HyH4XB4OQuP\nk/iXXjs/Fgu4iaoqglZAp9OhETmN0IaRrDVYAtf3cFyLWtXYiFXzS4v5fIpla2bzCe12xN7ONpFj\n4XkOtmXRDc2Mejyb0u622AhbTKempejGrQPm8wndtR5XrlxBa5d79x5yfn7OtatXsWTBeDKhKApm\nizk7W9ssypxkkVFUJaHT5uHDx+zu7dPueMzn6ao6TiMsjyRNsW2bOI7JpcQSjoHTKEVRlUjdgJYs\nGkFZxTh4BH6PdhBytb3P9OgJ7z58wHa3wGFGVeS02uukeUFVZqxvdHl2dMLW5jrLZWxkn6YmTRN8\n32PoDSnLmmejY7TWbG9vG2Lc48e88MJdDp+eI7TNtRs7LKYpfuDxnX94j4Kf0RAhbB9LG/65bjTC\ntbAaRW1rEOA0GPnKMk51F1C6QdkWwgLZaLQSCEuhMM1qYLrDL+JlsMqQC41QihILRypKBM2K8FbL\nGqnMiV1LheO55qZiu6iVFKhEAzYUpURhoRtJZjU4XoSwehxsdkjznGWW47fXkVmFbkp2d1qkSY7U\nLuubu9SNuan1exu0wgjHMYS9fr9rWNVKYysbqRyklpSNJE1rjh+f0Wu3OT0dMU0nzM891gZdeuvm\nBP5sdESxjJlO5vibW2g00+WS/Y0NRvMpD999myItoGjY2Nmm0Zp4Oodel8HGOmfn56A0oesTxxlP\nHz3hK1/9db79rb82uFWtkFpgWQLZNCAMm75CYWuBYwlk2aCVxg4CPD8y1aFhhGiHiLKmSnOadgvX\nFUzP3qa19jydvV/h+buv8OVP3eTFF26TyIo8Tdna2kJqzZ9/8y95tvgVcAX+oM+PHx6DcKmahrAV\nkOdT6lTx4f33+K3f/hov3HmO7/3936Ntm63tDc7fex/fdxmPx0zOZ3z6sy+iVEWjSkI/MkjQtQFJ\nNqKpU7a3hrRCl17PRdcFdZPjKo/FYkbLDUinGdqC81pwfjJhmdmELThb5hRpgbASstgs4OkiIZnP\niKcLgrDBcyyW2YRlKnEdwXl8TqUr6tJ4UNJFxnKRcn52DNqhzBuKrCBLZmjVplARvUiTy5y6dPFc\niziD0WLG3lYXT7g0okHKCtG4SLvG9S2UdFCyZnfrKlkzJk5rRkczrt28heWY7LPQitqWWI6DKBTa\na4iXc2RjIagpayM7Z1mG73qmkc83JtpO5NFudYjjmDRZmBiiE9DYHq5WLIuc0dGM65sdUjemrANC\npw26IUsS/DDADzyWyxjHcWiaCsfy8V3PMDaCkCzLyOKcPDlmY9P0VSxnKRv9NVQlqasK4Wlq2WBZ\nBnN8AaSKohZFluN4zqUhDrisJUZBnaf0ewMTK14FT6WUBqtclHS7HSxLkGUpa2tr9IcDZrMZvu9R\nFin9fpfI91bP33D79i0sGwP/avWoqgrZ6JUymhqSo25Mauf0nKoq6HTaZjx7/hCkianFcYxAEfg2\nXuAyjRcMA9PuV9c1RWGob0mSsNffYT6fmnSAlnQ6v3wb2cdiAbdc15wiVo0yUkoabeRYIcTK7Xjh\n9LaRdYNqGqTUlzutLC3o9XrISjJPElwaNjfWTCUkkC5jwnaHPE85OTmiMxiytbPD2WhEFPb48N5j\n5osFjuMhkaRpjG9b+GHEvfsP2d69vjrdlfiemQNOR0tc18X3PZp5TVXVRFgoJQmDFmEYcjYe4bo+\noaPwfdO2ZgtjOsvzFGFplLSw7BBbeDgC8jzBD2xu3Trg6rVd6sUDUBI/cKmrHMcJsS2XsizotAyA\nwHVdhILNtXVaLWMOsR2B6wnW14cEnncpr/muTa8VcefONWQl8T0ff83GdgX/3h/+Jt/76Tu8+fYD\nNrf7LOcJRZnT0tpAdmwbeREpQ5ge9pX8bTk2lhCmUWx1ErYsG8vCnMqV+T2xktUvyWzCYB3BNtAS\nbWGB5O6hAAAgAElEQVRJbRYipREraRKs1TxekRal6e3GxnX9FfSnwXMDyrKmrCVRCNnsjPFoclma\nUGnJ4uwIhMZzBYuqpKoUL+1+jtsHz/PhvXepspg4mZKkU9bW1tjb2aRpFEmWkhc54+mMtc0hAJ7r\n49sBb731IftXI27cfI7Z/YZr1zyCVoAXrgHw4MEHJOMJN597gTQzsnu71yas4fE777NYxtSyAkdw\n885tpqNzRFqzdnOHVqfNyU9+imVZlEri+R6L0Yi6LHEDn0wrbGFjS40lwLEcGmUUnYu0gCMsENqM\nmLa3cG2LJsl54cufxnVdxmcjjp4cki+W9PsDxuWStfgZre4Vfv8//i/4ZO+Qb//9a7SGQ7Y29zk+\nXfJX3/pbDg5uIKW/kiw1jnDxgpAAySIxysVaf4ter8PV/W3OT45xPZvHT464eXCbn7z1HrKuGC9G\nLOIFm5tbSKkJvJA6z2gFNq5T0YsioiDgyu4ercjDFjY40GkPSecZiySlLg4pyhhHKUZHR/zt33zX\nOOFtn9E45mQ0Q00nTOOYUimyokLpkjydkizOKasM1901dLm4IdwS9IRiu9vlsTUjsTSt0DM1urYi\nCBzCyCPIHFxHoWSDQ43nRWhRAwolYZnkbAwClIRKNnhuRFU11FWJ7/g0ZcOVKzdx7e9iC42sK3zP\nYXNjQFOc4YgILSxkY5TB5WJGuVIRsrwmTxNanTYKY6rFsml1uoznM2wlmUwmWKGLI+Ds+BlNnuB5\nBn7lryKqWoKqjZ9FVjVJMiOvUpyOxWKc0b56hdD3yfMCJ7DJ8oTxeMxwsH6Jso6iyEj3WtDt9Jk1\nM4IoZD6dIaWk3TV8cLAuZ+YXplYrEpRVBloim4o8q8wooMgJfQcLQRwvVi55Y1SbTCa0222KsiRw\nbEaj0eXIc2dnh6qo6PZ75OmIaK1FXZQo3eDYFt1uFz9wiRcVVVFz584dTo9PzEy8MiqGbEwHQ7vd\nJolj7FoxGo3odDroShOnOf1uhzLLsVyLeDGnEwar3gbF+vr6CgFroDtS1ezv7hHHMbL+yHT4yzw+\nFgu4RJg8r6XJygQA23axcKmqBa5r0+22uXp1n1ZoYgtC2VRNTVWY4nitHM6PZgwHXYp0wd7GFmnc\nQGgZ5GGtmR6fgxYM+uuUSvJvv/NdPvXyq1SVwve7fPnLr/IXf/EXdFpmoV1mJWeTCes7VygbyXQ6\nX5WudMG2mE0ybM9Ug/a6bSbjJULaaKVZLlPTEOS3VjSzgtns9NIBKlfoP9OvrRC2T5ZmuFbB1u4a\nN2/eYnr8lNe//x1+9eU9knhCFHaoLYHvuVRNyXBtk5OTe6wPb/L+0Slf+NznefToIUo3nBw9YWt7\ngCMESV7RjiJG5ydkWca1a9e4984DhlsDQj/i/Q/vsTZokRdLhlfvEkQRlg15EZuZjzajbte1EcrG\ncy3yKicIfOqqQgsbKUFJwxxG1ghhXeJuEQIlBcoCMKf1X4yRWQh0LXHFqkJUCWzbRTXaJC2UIVRJ\nqSlljSVsbMfF9TRaY7Lf+DiuzyJJaKRmNJpw7eomO1ubrLfaeLZ12S0ubYEQLhamKahB0A4k77z7\nffb391kuz9naWqOuY8bjEUenp4RBi/5wDcfv8uRsRllXpFmFbGI0km7f5tr1Xd589x5X97c4fXBE\nHXX4jB2A0Fy9fot/8zd/z82bNxmdnQEgZin93V2ePn3K/s4ub3/3e3zt3/+neEHIv/jn/zN+u8s3\nfve3+dZf/BXnjw/Z2thkNJlgaYVne/zdt77NZ776ZX68TGji7NK1z2pjpVdxPFsLyrrCdm1kI1ks\n5owfHfLF3/kN3n33fcIgNHSs0KZOc6ZTidcdcDq5z83uFe4Vt/jz//W/wm132N+uGG7e4HQ8I+js\nEPa3Ubag5fcQwiQuVFNTNSkd36WYLRGtDF0tSGYTpuMJB1f3OHl6SjYd87tf+4opqCgn/KOvfpbf\n/8avk8znhK6L7WiiwGW4MWS+MDSv6WTCYm6TLFJk1aCUaecq6hylFL/+q1/gt7/xWzx7dsL4eMLT\nkwnDtoduEv7vf/3nbO++zNkIwOV//9/+km/86n9LUZ/z9LRhWbncaXdZW+tQHtmktkfqr/HwcITQ\nMBqdIeN9LBxcVTI6OWc2Sagbc837liJfxGjtY7kSP7AQscV3fvg+v/q5P+D+gyPT1dBArSSO75nq\nY89jNs2IIosbB7tIGpMVX87oWzVFOqHV2aKqcxolTcWuEORJhud6tIZDtLDJqoIgiijrimRmnONu\nU5PWNRpBXWZc3+vz/PUtfvx4atDJtqBqNKenUz55bZtqumAxHiOkwm+1sRA0dcmTB/dX8CwPzzJJ\nk04UMZ2NGQwGLGIjozuOx9HRkYlshRGTyWRVJOKyWMQ0WpGmOZubG8RpwmAwuDSotjyBS0jRNAw7\nppXM822KNCPs98jzkixJaXf7aKGxXZuyqRkMBgShoakZPrpLsoi5tn+N09NTep0W7TAy9zGlkEgq\nKXn68IhBf5tFnBAvlniex3w+Z6+zRlGVBGHEVM7Y3Nhga32NWTZCo1FVRZWWdELT/NbvtXEsi/ky\nQbgOZ6cTok7I2empIXmuZP8o8jg+eUYYhpSV/P91fvy7Pj4WC7ipXjOOZuPkDkmKCrRplnrzzTeR\nUpLnmYloWBZaamzLfAPqusaUVBlX8GR0yvbWOt2WeQMNhj38qIOyfd557wNse4zSFiA5ODhgMBjg\neoH5Ac6WaKVZ3x7y4cMHNGXJUs9X5RRjol6Hoq4YH09ZpqkBszQ1TV1i26YSEwTr62tYrsUyWeB6\nAYCZ96yiZGJFMSvLEgsbVjN6S2hOjk4YdDfottaZLmbmpighCCIapRDCuNzPz0wb0WKx4ODgGmdn\np0hl5sK+72JjHORraxv0um021obUTUXgh9x96SaNkghl88qn7yAriWWvkxIShi2qCvqug2rEqqmr\nQQuMa3zVwZ3nOWHYYrqMufvcizw5fIjUApQwRRxao4QxVVmWheYjfKpWv8BQF8J44WwLaWm0AmGZ\nuk+JNrI82rTeaAsv8GiyBtA0jXECWzY8ePCAsG1iLUrWNAqwTJzNtpxLw50tbLQyQBwpLco6oeNq\n9q6sM1xvc//tB7i+g+dHWG7A1rZjoDfnY6SUDPp9BoNdPGfJ8bNneL7Fiy8/x+7+Go0b4aiAW7+2\nzYfp6gIVDb1+G6fX5bvf/Gs+9bnPwir+5/s+RVPRSInwAz792c/yr//sz6Co+Pp/+DtMRmPOHzzC\nboVsbm8yPh9hBz7KFhR5Tsvz2bt6lftvv4ttC9MQp00Jiu06RsEAbM9BVhWWbVPmKT967TVe/fzn\n0XnBy7/yOTOPU5AWZxRaIeqGNDmjrhLwOvh7X+Qrr25yZfcmf/U33yYvar7yla/iBS6axEikUpLX\nDcYRIFESeq2I/a0hb/2k5vDJEbawcByPmzdvUFewtbPNeHzKtSufYHNjiCMqNtc6dLvdleEn5fhk\nxHQ+w7YFlVQkiyXLRcrG2iaz2YI4NuCPRmm6UUSxnNKOXDqux5X9Xe7c3cP1fc5OjulFHmUyJhQ1\neT7hrZ+9T9Td5MdvH/Hew2f4HZiNPseDD+9DUjCrenTXN5jGz6gKiePb9FqhSXhUDbYbkM1npowD\nm6jrk+TG8FbXFRbw9gePmMwXWI5tEhPaqI15UdCohtPjh2ysXefVVz/Fv/rm3zEYrnO2mPP2u+/z\nG5+9SzafkSZLvJaLrk3Bj0bjBx6uF5IsF7T6XagUs8nIzJulxHFdur02joJcayxV4wURkpK6NH4d\nx3dQwma+zHA8myxL6HWGNJXpIshzY3oryxLHM01cYRTh+SYvniTJ5anbZMId9vb2LiNgFzL5RTxX\nJg11bXoMmrqkqV2i0Gc2achqiVYLwjC89B9ZwsFyTepGCE0Y+sTpEr8VXkZTO50Oo/F4dRjSlwVM\nWmu2t3Z5+Oiekc5tC8d1yOOYKLLo9HrUjSLPisusfdOY1IvruqAUjmUhq9p0c9iCLMmIPAMZ8wMz\nn5/P53RaLfwwQGrB2vpgxcQw3I+qqvEcG9/1iJdzQj+gzAv63d4vvXZ+bBbwwPUoVpADzzPGJNcz\nP6CjoyNakYfjOPT7XepaYumPXrrv+9S1RKGZzBc4vs+ToyOeu3ULP4zIi4pG5ViOx42bt+n3B/z1\n33wXyy5RQlHUBfc/uE+32+WDe+/x6VdeZbFY8PTpU8KozaDfYzKbMhh2iYuGs/MxWguE5ZAXKbBk\nc20NpcZYlkWwMl6IxuD6lsvksuLyIj4FJv9eVZWp2ZQGgmLrhiiKWC5ynhw/xmOJELtorcjSiqjT\npt3uImXJjRv75HlMtx1RFDl+4IJo8H2X+/fv8/LLr1DXDY8ePmEw7NCKDPDh/fc+5PrBFcaTKWWm\nOLi1TjzJsDx4fDpGOiGOzarlx7C3+0FgzH22DzZUdYVnu6ZODxBhgNJQlDWuNrhbhEIJs1hbmPms\nXlV4Xlzgv0hiE0pSrwoKlDDmOKU1ju+hhSLNc8JOn7PxiNDzefbs2WWNpWoMzUpK87EVhdDUWEqi\nm5paSOyV3F7WJcrWaOmunK+m93r/5hW+973vcGVrj/sPDwmCgCRLuXZwgyguSLKcooJkumA+bygL\nRRCFaFWwf22f09EjHjw8p+NuMLjVI+iZukBFQ6vVYvvgKkff/ylaKogCgkGXPC9xtcXJbMrnvvYV\nkjTh/pvvgGUxWB/wN3/5VwgJYauF34pAaCrZsH/tOtPxmDIv2dje5OnhIWWSgi2QjTKFJ3WNbRl3\nvcYQvqRoQGpUVjF7esLv/dM/4PjkmDov6HXaHBWPCNyQJFkQKpfx2fvsXPkMVz7zx7TCH/LGT97i\nvXfv8Sd/+h8Zt/cyxg9NEY2UZqPlexaWEkYa3tulrDL29m+wSCRa1/hhl6vXWghtsb+/i757lTvX\nd5kvxvS6Leq6Ji0SHjx8giUcyqbG911Gs9nKzVwYRnZVYrsWYSugagR7u3tMJ+c4nsXW9qaRWsOI\n/poB7Vy/YsyoX//Ki7z6qc/giILZ/Jxn4zP+j//zXxIvE46ePOT/+hd/xnarje0smGUJxWKK0A0/\neuNd/rP/5Hf45It3eOPH77JIC+KiJCtyIt8l8jzyWvLlX/s1/uJ7rzMdj2m3Iv7s3/wd/+TL1/ji\nl75MMk8pmwKBS10rPN9jbS0gCl1T+mFpsqzCdgNOTk7JyxvkeU7b9qjynCLPEVKTVgZ0IpUijAKU\nkgS+QxwXNNKwvG1LU9cFYRDhOw7xcoqwfIYbQ+R7JqKVZRlaC+7d/5Ao+nXyqiSqJUprPNu+7Cbw\nQ3MIEaIhjmPW/XWUKtnd3TXPgUXTNPi+if6WZYklNGEYMJ/PDVVNNjRlhYWiKjIEiqYsKJqGbjsA\npSnLmnbbJYoM59x1XaQyBrdWtLqXZ8bEGkURyTK+LL66AEUVRYHnwWw2o98bsr25RZaXpvjE8+gN\nbIRl0e30WSxLuoM+QTCmKgrqsiKILALfI0lShBDMZlMm43P8RuO5No4FjdBIpfDDgCA0Gwe0YrmM\ncf0Ae3WfCwJjnlsfDogXMwbdLovZjLW1NfQqifPLPD4WC7hj2RTK9EvTKEpdXroCLcumrioaz+zm\nzs7OAIu6MHnfKIqo6xqpFWGrQ1aVREHA8dkYgU3kOwx6LZbpkv5gjeFwne29LV588TlOTg95cP8R\nf/RH/4zvffd1tNZ85jOvsrezy6NHj4x5xHI4PT1FWKYwo6grjo+P2VzbJM1LpDY9xBeLUVEU2K5Z\nfNb7azw7fooQ9mXj2i/OirRSRGFIkeUEfkCjoRXAdDxh2IHt7V2SaYUWpt4x2O8xHo9J0xTPszg+\nGmE7IOsMz3eI4xlRFIFQHNy4RrHKQ15057q+Q6/fZzyZI/DY3NhldDYm8AbUvs369oAf/uwf+OGD\nM/zAJ8syHMxpW1YSe7UoSJMYo5YSHEGlNIVSWI6LLAocAdYKMKGEiZjYFmhpZN2LRbv5hTew1AqN\npLbAcqCuS8rG/FzH0ylOEHJ4fMInP7nFZDKh1zanNCGMvK6UxHMDPNtl2ZgbgSUFsq5QusFy/dUM\nssJyBFLUSBykBMtxSZIlzw6f0el0eHr4zETdpGJzc4fDw2fUjSJLC2zPpyw0Sla4XshksuDa9XWm\nswV5VnE+jnk6XZLN2+z82ufM/00V1JXH7v4+R+JNTh8/Y3Njg+2dbe69fQ/btrl59w4HV67z2ne+\nB0UJSjCLF0xOz9GrCk3Lc5GyYXf7KtcPDjg+OWY6m9JbG7K1v8vhvfs4todWFTIvcXzPiBauhWwk\naNN0RaVQZcWTsyP6H3zABw8+5Etf/CJVUUGjaFygqkiqhFP5c7b3XqHuPsfx6d/z45/9lH/yu7+D\nVjVSKHzXwhIOCoXj2dBUWNomzwpcy2Uym5OWc9pre8gGZNPQGnRoBS18y+H09BDbafjBj35AFAU0\nSpFkufE2BKbAJ3TMxvf69Rs8ffqU27e3WM4XRnGTBe1OhBI+RRmzsbtJrxOyLGrK5Zj5Ysp0keBb\nHkGvzd3b+3zla1+i7bd5/PgB2bIkDDyev7lHx1nyu3/4eRxlcePaXdb2uvztt1+jVRf80W9+nZ2r\nbR4cjhmfjynrhm/+3Wv86X/w+/T7Q8ZHj8ENEP0NzsZnjMZjsjQlsF2kZeE6xrBUNppWu40QLkq2\niZMFg16PqipJsxjLgpOTM+IyJS9NzEjphjLPyavCLNqNxHItIj+griWu76AkSA2DXo8izej3eszi\nJS3fpsgTCFyUqlCy5ubBAZ2fnjBdZHT7PiKr2NnZI8sTBr0uTSXpD/pmVislvu+jLIXr+GxsbDCZ\nTDk9PTVfXx1KkvQjh3hRFJfXZt2UbGyumbmwNP++66x4EqqmWeXpLcsyHhmlqOv6EvB0YQYLfJ8k\nztCrnoeLk3YURZcbBlb3KqU0aRqbyOyaWdSXaYKwHbQA1/OYLxa0OxGT2QJRS5LEtJetr69j+xHJ\nYonvewQrj0AYBizOThDCBkuCHSBQuK6DbCqqPAfHRenGcOBXTXRSNUhZs4znhIEPWtJuhebv8MuT\n2D4WC/iF1BJFETsb66SFacjR2gz5X3rpJY6PDw21px0hhE1Z1pc56jAyrOssy8CysTyX6fGStd6A\nzbU+URQyHPZotOLk5Cl5HrO9t80imXBydo5WFu2Wac1ZWxuAJfj5O2+zsb7D2XjMYDhkNJqYHGMr\nJIoiyrrBD81Hk/1Wl8AZy7Yp8owkSfAc45QuyxJv9Wa42C2WZXkZ+yjL2swrUWxtbfLKK6/whU9/\nlp+88W2iaMxLL79EU9j0fA+AXq9FlkrqJkNLG6lKtrY3VrlJ9xIRGEUhu7vbrG/0QDQruf2AbJng\neA57e+vMpwscS5Elc+7cuYq1cZXvv/4GoWPj2IbuFtjh6qIxxSOWbdNUDa7ngl1zMh3juD51kaOU\nAC1RjUkQNFWNcCy0axm1wfpIRkd91F4mFFir+fhFvEwIwTvvvs+V69ewbZuyqul0uriOa+bv+sLM\nbubbJguOMbVJidI2jYJSmlO/67gUZYq2PTwhUI2R12fTBO3A/t4e92YpaZrj+ubUcXx0Rrdv5ngC\ni067j+0IprMl7bbL9es3DL5zsaTb7ZIVMD6LWVeGjqeoWcYJu+ub6I7P6eOndNfWUHnFoydPuH5w\nhasH1zl+dMT777xrXLq15vHJM6q8AFvQ63RJ8wx8j1dfeYXD81MAkjyjnmo2tjZZjibMz0Z4wsZ2\nXWopEVpTC40tBFKpFXzDQkiNWzZ88MZP+fxvfZX++hrf+uZfE/S6qKzGE1Bpm+n4lNn4AcPNOyyi\nl3j1cwtGk1PK2ihTWV7Q6phyHDCgjeVsiWrAdULiIiaXMW4QYgmfpoG0rFkuZ/TbbVrdAWUxZ1kY\n1O3DwyNcL6TT6dEKQqLQo5EFa8MNiqLgzu27yKbBdz0GvQ5FkVMUGYtc0mRzFvGEOLWRVkDX9Yla\nXW7efYFuEDIvamYnRzy6/5RsPieM+rg6oFEZf/iNf8zVzecZ3ICmhGyhWWbHfOlzr/K7X/k9gm6b\nklP+p//l/0Upl/myJI0LHh2esd936Hf6NElOlTUoIWl1exRZuXqfQ5oVtHttprOcsqlwbBffj9gI\nIurGfO/ydInnGuQpRXaZWLFtcXnfsASEQZtcVfiOS9loVLOKaSJwLRvt+ixnCzSKWjSErQ5xXdBq\nhybq5Pr4noNnO8jKQJBc27m85nZ2dhiNzy9hI4YfYaMUlHlpWh+LzGyg0hTbclelUhrfNw2JTVVT\nFDm2UKRpvHr9hqEOYNngeqYopdWKKMsKpcG1BfF8YVoWowClNZ12i7qoESuCHY5JLawNhoRhyHI6\nM0rECmJjnrNFVTXMZjOm4xFRd8B8GdNITbOIWSQL3MDH931Oz55x7949+v0+gefy+NmZyby7Zn69\ns72J5zimcwJIkjFRx1lttk4IQx/PcciqlE43oqwVw+EQqRpG52N297ZZzucEvkscF5c43V/0Af27\nPj4WC7hWJmt8++ZdDg4OWMRLHj58SFPVlE3F+sYGi8WMrc39VYyhwfU0Ui0ARdTqoaSZ07hYhK5H\npSW1bWG1+mxf32M+PyUUDes64vDwIel8TuRGjM7GWC7ceO6ADx49oqnhfHpCVZlTY10XfPj4AXle\nUeQVdr5OK+pgCZuqVji2h9DgOkYSLuoKz3LYv36A5QimiyW+H+D4Ppsb62R5wsnZGX4YUCKwdY2W\nUGuB6zqURY3nVLz2w9eI8yX33nqLP/lH+5CVPHg0obfZIbAFzx49obPVIZvMaXdCnjx+xvWDPZbL\nhPFoQasdcG3tOk0C49ncMKvTcxZnOS9/wuLB+QzHEmxuDHn08B7bG0NYKALX5Y++9gmi5IT7j0ck\nEmg5yLoABFZV4lgO2nZM/V+xJLQFkycPEJ5F6HUoS4nnWRB4aK/FMOyhlzEyX1DWDa4bYDUNUpdg\na3zlEOuawnGRtsbSNU5j4aYSt5b81qd/haxu+MnsEaU2WNdGKxopqZQ2NYzadMRnRU6lG6q8pnGu\nMilGFKWPIx2ElohSIWgjHYGqMzyrhS01eQVhIZmN5mRJQr+/w8PDp9RKcv3GNr4X8e47D+n2+vQG\nHp4XcHDzOsu45PHhmNFoQr/fR1Y1diclPbPYv3obAMsRLJc5/W4XO2ghy5TZYkK+XCKXC7TcReUl\nP/vxD6hmEyP1DVsc3X+CaBqC7Q26wwFnixmf/62v4/RaPPvpMzNakIqqLOl1umxubzMfT1DCMtjh\nxigZVmM8CUI3aBTatpHKIi0qgm6b27ee58//5b+ifjqmdXWb1o0tjj98hOe4hF7Ik4dvMNy8Q9N9\nhejxN/F0jWpanGcWQbSOVIW5eQobRzQI10U2CiUsqkoTBq2VObFcAYhsnMBhks/wPA836LKz9gqj\n8xPKJMGhpCpKzo4qfN9jb28H2oqySgmjvmmtsiTjeM5wOCSpK6TKUK7H1YNtlDRcbq0Fy6Lk/N7D\ny1mtlMb3Ena6tMOI/b09HAFB6KIaaSpzUQy2QnrqyiXDvyimZFnDn/7JV5nFCf95q8NyucQlphJd\n3O4At7tF5ES0e5vo5h7CCqn/P+7eNMbS7Lzv+737cvdbe1VXVe/ds68cckhKJGe4S5ZsRUucRLLk\nIIkty5Y/OA4MfTBgRYrtJEaCAEEcC5ItiYJEKhRlyaJEazRch+QMhzM9M909vXd1dW236u7v/r7n\nnHw4t0v6zi+ELlANVDcKKNy+73nO8zz//++fFdQo6Q8SXNOi3WkwHgyRdoVft8jznGbY5P7hPXzX\nQWQVhpUhsZkMFUHoIgOHtMyRpYsThmR5TJymGHWLNJrQaLQYjxJc12M4nLCyssRoOKDKU5xaQJXl\nBI6JLEpUp01cmNQqHxWWZBU4VLx++S7/7c/+TazBXaoyxrZDbF87aqSQlJWgXm9Q5BWpEFhegGOb\nmEWJ73vHbIY8jgg8n2k0plX3kLPGxjQMkihFiBLH1aI/KQWmaRBFMUVe6bCSGcEuEymupZ1HUTJb\nOboupgmizHQ+Qpph2w5pJel0OkgpSZIMP6zry7cpGI7HuPUmvf4elulhuxZZFeH6HqV0MGomg6jA\n9l3qYYOrl4+Ik5Sw5iFsh7RK9XrPDMmNKQYuQXeZLJ7iZCVpFFOkGbVajVIqAs8myhP2dw8IgkBP\nDiZTHMelNzsj9ATV1cLt7/H1/VHAZ+OQsiyRM/GT7qQUFiZRlFBV8njvkec5cZxS79TY3t5mfmWB\nPM3JhaTbnSNKEkwrYDLN+da3X+Xq1RqNuo2SBQ8/dJG9wYi8VCwsh1y7dYOvvvINzp8/z5/8yZ/w\nUz/+k/zRH3+BlfUN3nznigaCmDa2E+Aph2kcU+Up3W6XqpJkSYYZWBimixJgOQrLgu17dzCtma/R\nKJHSYJKMEYUWXRWVoNloUxUppsqJ0xwXvTcej8dUasrel+5ilRm+XKeybXLbRnk1pAVH+yPmnAZF\nWFHvdOmkAtOr0ZxrEDRWEKIg8BSeJ+k2a9TqAd3uBp3WFLfW5OyCxDQt2u0W4ZkztFot0iKnLARm\nLnVh3z9CVAJpWkipCHyPXKZgGMR5zjSasrC2hmG7LHXmCJodDGXg27ZmhZeSRFgYjstE3od4NGOr\n6w+uZdsoU5FJhWM6oDRf2TZtMllheg7ycMK/+Ff/mr946SW++9bbuJXAUhKJQSElRpbRaTfJ83xm\nnbMJ/JDpdMqVd6/pg1waM5CEhsj4fo0omRL6PrklKIsUw24gcbDsGlklONreBtNGmA5nzz/CibWT\nlJXP3kGf597zfr7x9e+QZ2Ou3b7N448/imnabK5v8vXXvoEQJXlVUW9oq5lhlMRxTKPVxHJtiqoA\nbMo0w5YKEWfsHe4zHAywTAtZChbW19jb3sHqNnjqfe/B9XzOLM7heC7X37lKmRd4li46FgbZaH+4\nVIwAACAASURBVEIyjTBn/ljPcaiEAgxkJcHUYjZj9t4rA6Rj4LsWr3/t61SptvC4nsfDFy6yc+M2\ntmOjspL+0RZpdAT1ecqFJ2kkl1GWhWlKTENq3YNnUFQFWZUjJZSFjp6tqkojMz2dFCeq6th98eBZ\nLoqCPJZkiaIqHdIsZdDr02qENGo+aZxx7do11tfX6PePtEMkjlhaWkYI7eZYW9PwEIDRuE+elTPh\nqyZ6PfTQBRYWFqjX68fI46qSICsMJWfjeI0alVJSJDG+75LOCGGNRgPfruHOz7FhGjNLqMCyDKIo\n0tkAlkuj0UYWCa16yOHuAT/xQy/w5MUNDg9usX84ZH9nX9v2jo5I05SjoyOmkwkWerx74sQJrt67\nj4nFjRs3MK1Pk2QCZYLjOlpYFkV4YYBlOccCXtu26fWOWF5ept8f4vsuRVkiq4paramT2iwbP7Bp\ntepa9FdIlDJoNWp86Usv8QcfOMsnP/oQxUhi2DZFmuK6DpgmURxxdNSn3mzg2B6GpddeD1Z0eZrh\nOS5BMyCKIsIw1O9jUeD7/jGJ0Q800dJx7GML8Gg0Rim9WtDCWN3pjsfjmW1UYZr2sXZGCI2QLcsS\nIXS3W5Q6WEWqCssNOBr0KbKcxcVFTNtiPLGwLVuvXGVJXlTIKmNubpGHHr7At67skExHqErQbDYZ\nj/o0whaWZXI0GJDMQlowwLJMWvUGeZ4ThiFpmlIUBdUM3b13eKi7ayW0D7/RgJllLJuhcvVl5K9J\nAbf4y5jKB95ADQgBA108TMM+fiANw2AwOCKsN7Ash/39Hu3WHKNxnyguZg+jotcfIaqMG7fv8MmP\nv8j73/8cL730RYJmk2anizAUtutSiorTZ04CsHuwh1AGUZyRFArb9zBMizTW7HVtbwMlNHu3zDOU\nVAjAdjRtrMwFjmlRqZTpeIySFkIV9HZLDAMs20FhMhoeYaGwUIRhSPFgzG76hK6Pb0lCS+LbLla7\ny0bQQuUpFoInnn4UM0mxmw0m4yEnN9Y56O0hhUmnvciVK+/w8GYTyymZjMaYrkdhujiO4M7tXRaX\n2mR5zpWbN1ldXeb+wS6Li4u8ffkSy8vLCFWRlBluUKfKBXuHE4K6g2/6CMPEqc/xy//mV7m5vc8b\n77xLJhU7gxEiz5BFhBSCSVoS5YIknrDY8NlwW6isIKkyHNtDKEWRJwSej1sAqqIWOCghUS4UVUp5\n1OPKV75Ktt+ja1rUDIt+VhBTsXfQY3lxCYMOWVrQarexHJetrS2Oen0Mx52J1DxyWWEYivMPnefy\n5ausb6xw4sQK3/7WJer1BZRl0Y8mKFNx4tRZVtfP8s6VawwmhwjL589e/hoH+wPGk4SqtLh2fZtn\nn3uWRv2Q02dPsXNvnzdf/y7RNNViPSxqjUUADg72WFoO6e/sYUk030AZTMZamSxMSZmklFWJECUU\nFSdPn2J/e4dHnn6S7iyYJRcld6/eYX9nB1MqLAOi4QiRl+ylGXmRI2eq86qqdKCGsBFoxb5W/Cuk\nkiAUoWky2LrHW4d9HnrsMXZNg2g6ZWFuHsN1yLOCmu3ieTbbd17n/GOfIGo9Q5jfwjAkskgQJjRb\nLQ4PD449s7ZtY1sO7iwXPp8pnl1H74MfrJKKophhJm2m05xmvYtreYz7A5p1gzydcOfOLvW6Q73l\nEkVT/EAHAS0tncELw+PDvlarUVXVLNxiTJ6VOuJzNoaeTqcEQcB4ovkIlm1QzeyKWnFdMNdukee5\nDlKanU21Wu045/5BuIVnmFClCFGgTBPHgCKKmOY5b7z+TdYXmxhPX+CDT5/jUx96DqOKqPknuHXz\nHtPxgIWFJUzTZH9/H9dxOH3qLPV6g+9evkGSpSwvLpHmI27dvMtolJEVYPswGQ7pzs9huZ72kVcR\nAoM4yvCCGnG6r4OWXJdCVAT1GqaRYSiTJErxAoFjmtimFggb0sA2XRw7IC9T3n7rXX7kU88Ql0NM\n18HCPhaF6ctPSpymrKwto5Ri0O/TaIRURYnj2ri2RS2YUdBcezb+t2Yi43JWcMWxq8X39YrKskwM\nw8RxvNl6NMeyNP1sPJ6yvLzM5ctX6XQ62nFimuRZSb3Vwrb0hSBOpliWdcyFr9Vq5HnOeDqh1Wox\nGAzotJcwsSjSjNUTKxz0BnRYYHfnHs889TTRZExvr4ebCoo8o6x0KMtwNKU/ntJ0XExMkBVS6rXv\ng+CYRqNBkiRE4xGdZpPRaIQsS7qtFs1mk62tLbrd7nGQjed5f30K+HGKTqmLr5ghPqSUYAhMQ2LZ\nhjbqWxaW6WBZHiIrmG+3SPOcJB5hmg8EBBWlMpGlII2nPPHk0/xv/+v/yS/+o5/HNT1arYBRf4Ll\nFNQcn/Mbp7n+9jVGe4csNuZohS2Ggymd7gJ5njIe9cnTGNswKVLJ/MoSTz52locuXKTVaXPixCpf\ne+XrXH3nMuPplE994pP87M/9NEk0ZX6hi2U6OvISnTyklCIvBRKDcf+I4XRCMh3gGhbDaYwyHJAF\nyfiQ0DGoQkkaj2hLgVfT2ME06iEMUHGJUWYYRUTL0w9cHu/wwecuIoMuwuxTb4TM10OEcrDsJuGq\nQsgMx6uxuFqjEFDvLCANl+W1k5SGgd9o4bgh41jimSbPf+yHuLp1yN3D+3Q6HfIy4+/9T/+M0A9x\nbYfDvT280CTNSzzTx6wklq0wLUVNGVSli9FukkUG0yTHIMU1FJaykI4gb/i4YQOKBMMCRyoKaZFv\nLPOrn/33GLbDtpNjVzGqXUclGfPLa0wmY/bfegvbtjl39gL3D/aIM0WjvUCUTvjYRz/Gu+++y9tv\nv8H7P/Be5hebjL99yA8/+SkOjg44eeECN27q9UPomShZ8dyzj/HFP/0qd+4c8PwH34NhhbQ7i/SO\nYhaXNfSn0wmJkhFxmvHGd95iNOpxamOVVuFhW5L9XoofdigrGBzuMuynWLbFuYsXeDe7RDGe8O5b\nb1OlGXXbJ7Btit4AUyq6508zt7HCiz/xo8w3W4wjDc042u8RD8ck/TGyrBAzIaRrWkghqSzYOHOa\naDplsN/Dsm0MS3OshSiQMxGlYemDI80SGs0GG+sn2Lp3F1VWbK5v0F5YIKjXSAZjyrJA2T5xcqQv\nF+FJvrNf8b5HV3GKHEMqhuMIP2xQJNFMmKgFjc4s0alWqx2nSj3QN7iue7wOMwyDTlCQJBEYgpVl\nTbzy3Q1sU1/uk0lMreYfU77SJKeq9IUeZVILG1rkJA08N0BJizTNyTKN5wwCDVZ64H6YTqeEvkGW\nJxgomrWQLE2p1+tUVUWc5sfOEcPQCXhxHLO+vs5wMKUSGWHoc3BwiGNrS1OrXeP02TM88tRTqNKg\nqqSmdSVTHnr0McpSkGcd4qRgaekUR4cHrK6tY7s14kzgzZ3E6QmS+D71hs9bV7f45//q/+Yf/vd/\nh8lIWxh7e0fEMzQ0aAeOlIq0SClKZgEoIQsLc5Rlzn6UELrgBSGVmKKUYmNjmblWk6wSNJsOlVRg\nmDz80KOEYY0yjLE8m7xSVHlBp9ugXq/jGGBjkMyCerRCvNA7/0ZIVRXERUSrXT/Wr0j5l8ASPfmo\nU0lQymI6meo8dVNbxnyvjhmYx0jVIAgQlcVknLK5cZogCHjnnXdYXFzEtiVJ3qPT1rCueq2twVjo\nRnBubk47TvKcslQ8/sgTKOkwHk9YWzlBGk9p+A5FPuW5Zx/j//3dr3Hx4kXmFueYs1wMy+Te/W1M\nL+TVt+7x67/5OX7mk8+wubbK1vYeXhgc+7gfCOCCICCKJzrp0rPo949YXV0li8cEvkuv19Ofk1Zr\nNu5Pvufa+X1RwKXBcdrYAyuAxEA+ECbNPgBVVRH6Pv1+H8f2KB2PdKLfBMetsGyXfm8f04KiyPE9\nmyKt+Ls/81/zy//8lxj3D3Bsg1boYmJxevMk48FQJ+d4+kDZ27lP//AIz7WZ9odEkxFlFLO82OHk\n5iY/8IMf4rnn38uZM2ewDZM4meIFAVke83uf+Tyuqz/Uc606B/fvMurtMh6PicoKUynGo4HG9s3G\nT1k6xcLAd3QyjuPpw67d8Fhe7WDbNve2buG5Aa3WAnlWsri8xlqnS6wk7VqLKErY3b3PJ3784ywt\nz9Ef7HN/e5ferVuMIkWUJuwdHWCYJkeTnNXNBQ53tSXnxIkTXL16lY2NDU1hEoI8L3Ecj6yowA7I\nkfzZSy9TnzuHKkJ8u8V0ktBpdfB9nyLPcHwTqgrHsqiEJPQCsAXKLnE8nyIziN0aa4+u8eLjj+I7\nFqiEwaBPb2/A9Xu32OsfcKrmg1CoIiOuYo7qChn5KEwWNk5zd2sPMdHJbpZhYgYupVD8+E/+OH/x\n8pe58u41lpdOYLse6ThFGXo/DjZZKvjgBz7GnVuHvPnmm2ycXmduvs1wMKW3t00zdDGQfPtbMa1G\ng/m5OXbv73Bv6yaykuRpzmgw5APPPsnV69+l22mwtaUvoEVRYNkQmA472/dZ2XwMqXSH0em0mE4l\nO9t3KFpd2nNz9NIMVWlaWpXn5HmhufKl4NS5M5QKut150jxmEkeMp1NkVVFmuf65UuBgUBoGQkgd\nfepaLKwsESeJ1vRJbQfSnnsTLAMlhRYPIvFcn6XuPOdPnWM0/O7xM5bnGZ1Gi+RwALZNWRQkaszg\n6DYLSxeI3AskqmRtvkM+HVMLPERRUpubR4hST6lsPfp8wLNWSuE4zjET/8HovCgKGo0G0cGYIHQY\nDgc4rkWSS9KZCtl1XdzAZWlpGVAUeaV1ML7HZDLVqmXHJKyFx+4VdwZYyrLkWCQ7GAyIYz2i9TyP\nZrNOq1EnMxOyONFWtaOjmf9YgSpJUz3mbTXr1GsBqBJp2nQ6K/iuSxB2sC0X23OZTsdIpVPLPNOl\nrAziUhGnCY4hcBCEYYjlhVRVecxwCNseX3vlVW7fucv2vR1GozF2o44yDK6+e5f9Xp+6bWMBruUy\nkQVBELC6skReVPR6+7pBsC0kGmwkURwcHNJealHzAqQoabpNTTU0TKaTIZ5vkWcJnumhlKDZquN5\nGo9qK6lhM7P3LssSneZnWzi2hdeoU4jq2L6p/71CSs3U1y/jWFHuOB7ttkcy81z7fjBTmmsf94NJ\nWZIkf/k8WRaGYRKG3nEqZafTOZ6IxElMECQ6btp2qNdDer0e8KCeaDaH63qIKkEJvcpBGpqBrkCJ\nikkSzfLZY3Z27mN7teOinGYFfmBy+/ZdlhY/oclqno83W/+EYchgMDieMsRxTK0WzDI8IE8T8rIi\nrDX0pClKuHPnDmdma8vv9fV9UcCFkghmCVVSwzp0MAZgOoAWkuzs7sDyEuPxUOP7cI4hHjYmjZpP\ncGKNZqvOmVOrTCY6CWc8OACVU5UJeSZI0yZlmdPr9bhw4Tx5ldGea5HkKZbv0GqEpMmEH/vRH+Hr\nX36ZVqPGL/z8z2uVpqXIoilfefkltm/fZTqNqbVaDEZ6/GoC21t3+f3PfZZhfw/fcQmDOrYX0mzU\nWJmbw7INWq0Wvu+zNNfBMkosc2aLqNdwLfBNSZYVSCfgI5/6YezmAo32Cp/5D59lrxScXXmYajzm\nG3fvs3VX84f/9HKf+196DdMqGQ7HbBqSxspFrt/bo9FuYJgCL9BriU57nnajhWc7rK+u0arVube9\nrS0heUl/NMR2YBwnuH5AvdsmqwSGqmNbdTqtZY6GPRptmyQpMMIOa4uLWIGH7YaowuDwcI/1E/O0\nOm0QLvu3b9M+d5q//Qs/j1FJKjKkqZCFQFY5f/6FP+aPfufXIEu1j7SqU5WK1fXTKKH48rdfh9Ik\ntG08x6OoSvK84HA4ZHdvn9E0AsOiO79AkeWc3DzDQw89zObmSUajEbv7PV56+WWwTHo7Qw6ODilK\nKFJB4Comqb4oimpM7zChlDZZPuSJJx9lbW2d3/6tz1KrhQhSbQH0PcqixDYdpDCo1ebwjQT/1Cai\nXkcIC1DYvsIpLMJGk9FkjGNZuJ5HmU6wlImIUpLxVHfI9YATp09xGEeQVxweHSAw9F748IhqmlCV\nJZYCHgj6ZznO73nve7Bch2k0ASFwLZfCkDOoDtoBoAAMMEzKSiANgzNnz/Lam2+Ca7N/1OMLv/c5\nTq5vcLizS5WVGK5DWeXc336ThaULnHrk43zn0v9B7cnHyKKIWpnqTl/YWPaMdjXbzT6wVzqOQxTp\ng9K27Rm1y8Z1XR1wkbbJ4gzfamMqkzIpSYuUWi2gNT+PX7cYjqesrSxpS5LSY/H5+Tn6/T5CVIzH\nI/I8RyktaB0NJ2BIGg29rzw4OOD8uYs0m009Th/r3avr+RRFgRv44FgYWJhS0Gp7M6eIPP6dLcvA\n8lyEEGSlIqy1GE/6yCwC0ybLK2y7TrPTJsm03qPp2NRcE1Nqu1QudNOSJhGeFzCeRITNDu1Wk0bd\nxzVh/cQaly4NkMphYWmZnVs3WGw3uHb9KhtnLuL7Pnt7eyjLptHuoCRsbNTp9XoMBn3KQhAENRws\nap7NZDxBGSY2dVq1kHrNwVEabRy4LhMjxrJtClERNhukVYElFLZjz/bZoJTADTQPQifcaYtUVqQ0\n6nVtsQKyPDnWNXmu3tVHUTSjkhWzhC59CSmK4rhDr8oClF61JGWJFALPdagKzYNXSh3nikspadUb\nOlciT6giiec72qKmJJUoMC2I44iyFHieIolSut1FJpMBpdIrlrQoiaYT5jpdXNsh9HwmSUwSpahS\nsLgwh+ctMd+d002h42K4mv8hKh2junJi7Vgg2ai3sGx9QciyTHvjHZuqyPB97WOfn59nYWGBKIq+\n59r5fVHApVLH/+G6dTAxTZvKKJBC+wN9L8TA4ODggH/4j36excVFVuZaeL4+AHzfxzJtfM+j2+3w\nmd/7DLs7B/yDv/8L2LbJh37weX7j3/87tu7cI05z5joN9nq7vPfUe1GmZHV9hUKkbJxcZ+vOLaqq\n5MTqMp/42It84sWP6ZFHllPKmDQvqYqS8XBCs9nBdULm52o4dp0iH+J4FR954f0YlUUjcDHMAs8z\nUFWJbXFsNwOIxyNcW8eDGhYk8QTTNYnKGGm4CLPN5SsTPvXTH+Hf/tbn+cwfvMRbl9/h5/7ez/KV\nL/4pt668CsphY3OTf/yL/5S7Vy8R1gyUgq/txCx1Wzz9wY+zd+UShhJYErZu7tLquFpM09vHtByu\n7u3wN3/qb1MJMIqcfjTERmJLhSoqVs6eoLIXMLwWplXS2+ohbFg7sU5VSRqNmo5zdSTDwZh4lGEr\nh3yYsde/j6wkpkj45re+zFe//AyqdCkxMVwbSoXIRqyfuIg9t8xqrUk2ijlMJtx87RbLH1vjz7/4\nEtdu3+f97/kAIs8QVoXV9Fmsd1hcXMbxA5599lkUpha1ZDmNVp3LV65zeHjAiY11bt2+yu7BXa5c\nu4LrOHzow8/zyjdfI4oGrJxc4ZknH+fG9Vu8+MmP8sZbN/jKV76tk8vylLXlFZq1GnkpsOwKBJS5\nwLUs6o2QahuUdNncWOebr3yFducioJnZpuVgWiZdv85Bf0xSJFCWmJatyXm1gDxJQcDSqXXMRohV\n5GzdusPe/g7PfeADDA+PiEdjbKVDYKSpO2vbtMjLio2L51heW+XSpUsUZYE5y1C2LBvb1ilwUmhF\nsRICpTRHYWdvjzfffJNG2CBwB4gkpX/nPkudOZYWF7h/+x6GbWIaiuHwPpPJAc3mEu7c8xyNdnDL\nElPE5JXCsFw8x9T7WaGJgQ/G1rVa7Ri48cBupEFBmkJYWhC22+RZhiEFvmux0gixfYmgJCs0Mvnd\n6zdptRuMRkPC0CfPU+bmOsfiJ8NQgEm73aLRqOO7OncgiTMunjtHUegpXzTRo860yAlcD8u2KUXF\neBqDadCqd4gKiVQOWJCXFWDgWu6sQFn4jsvR0RGF1BfOMGjg+XWSKOHuzgFH/R5pmrKyuEDd95FF\niut7dOaWqGaQj0pIqgptaXJNbEuwtDhP72B/NpGR9A8HHPb73L9zDcuyuH7rJhsbJ8iSCMfTnez+\n3gF5nrOzvc0LL3yEIs/pdDq4jsIQFe16gMgSnc0dT7EdA0uiL3VSIZUecTuuR5IXCMvAx0BJqb+U\ngR8GM7ypS1Ho86rKSyzTxDDAtXTMaSEejM21/S1JEsbjMc1mWzuFHAchdIKa53kcHh6ysLBAUWQz\n8bKFECVVVWCaLlme6otGoMfWw+GQTqejVyGJDoyK44ggXCDPMxQCw5B4nke9XqMoJSY5mZUfJ6cp\nIRBFiSEUC/NzZMkBqt1mY32dV779HeJJzMJil+l4ykEy5KmHV5EITM8iGaV4jvZ8u4E/E1XHhLOL\noK1MJiPNf3+QvlYKSRzHTKMxq6urTKajvz47cHPmc1RCYiiBSTUbx0iULemP+jRrPs88+xS2bXLy\n5Ekajo9nWTS9GjU3IPB8bM9lHEf0B0MqaaGUwb/81f8FPwy4s3UbacxSy4KQcTFi2BvwUyd/it7O\nAfXna5xa3eTmlXcxHZPBsMf1K+/wEz/2XzA4OqSUOmpOWYJ4cshyp8bpT38aqQpqnsN0MObXrBip\napSJZK1pE6cZlCO96ytyRCoxLJuiyJAqJ6sSPKdJqbSwYToaEzgeh1FMVQiyvMT1Ay4+/6Nce+c6\n//TnfgYDiRes0emsc3B4QGdunSzOyBIDxwtp1LuMxns8/NAphlWfr196m9baxzh0Q557+gnmOvPs\n7eyzv79Llk3wvQ6PP/M8a+eeYnP9BK98+Tu89dZ3cN02yvZRVKBgZWWFce4yiiKO9g5xlIFXbzGN\ndObyYOBjGhqnWKSJzuq1HYKgiylLDg92+Se/+A94+S++zN0rV3n1tdfZ3jtgde0U73nfB6g7Kd/4\nyrdoLwZUouK5F59ie3ubcZZTZBnN+Xned2KRkytnMFWFG1Q4fkAyjRAV9Pa3SHPJ4kKH+9t3cByL\n3v59bNfH9iuGg4jRMOHDH17l+rvXSdKUk2eXuHmzw2B3jKUk08E+RTrh9v2b1NsGSVYRNNrcunPI\n0++dEjRM4r0CQ3qUhoHtWqSpoObV+ciLH+ady+/y2ptvUkQR7bPar2+YEtfzsQT09/YoJxPAACkx\nZqEvfi0gTRLA4JEnn8KUGt/47rtXePTxJzizscmrX38FhMDGRkmFsmaBMKaBadmcOnmSKNJpeEYh\nMCqBgYmQYraIMmbBMjbS0tQ0JUoc29EHaLfFjRspJgYENfb29licW0ApOZvGVyBNrl17iWef/S9Z\nO/0C6f3PEdg5ZhjSsW0cwyRoNI79xDpAxplRuWyKMkPO/LpZnMw87npEe7S3x/JcByPPmQ77hKHP\nZOrihBaGBUUWce7sQ/h+SJ6l1Gp15todhBBEI73bFYXAsHRhlULSabaI4gnT6RTTsImiCN/3NWpX\nloR+QJEXTKsKz/OIogiFge/6FFWOadqYtqm5/MqYcQgK8iTHcS1SkWLMQEX1oDYTV0XkRUGaJMiq\nZH11mWY9xBQKy2tRCYEsCxrtFpVQZIUgGezSDS2eefgMxfiIH3jmKYbRhNXVRX7w/c/j2xaeKPD9\nixwNjhhNhkyGI2q1GreuXafV7pJlGWfOnGF9bZnxaEC33aLTCCmKAqVKTLNEmiadhZME7YpRleHg\nkVWC0rDxDMgqg3s7CXghddPAJsMwTJTSQl+Za0W/49XJqzGGYdBotJCinO2t9Tn2QHHueZpvEccp\nBjZ5VmDZHukMwgVg2Sa1eouyMsiyGNczyWc52WEYMo2GjMYxQVCS5zquVIiK6VRnn6uqIplGeI7N\n4PBI1xNHY5PLvICqRBlQCggCn7IskCKnHtaYjiM8z6MQBe12kytXL2GZ+nPihaHOf/Bc0iPJo489\nQV4WBKKkHnpkhWJuYYk0TZlOp3Q6LQ0gcm1sx6c/3mZubo40q/5KoTaPO/0iy4/fg+/l9X1RwIsk\nByGxMTABx7aohz69ZITv2vT291DtBudOnqbVCLlx5V0WWh2kUZElEfWwRqfbBluHXLTmu5w6tcFb\nr7/Ou1evaruSAco0aNRClNAiKTKByAv2dna5dvUKz3/gfYxGI25cvkM+FfSPenz7m1+hKFMWFjrs\n9na4cOJhRJ7heAGBmWHYFq5fEqxq1m1UppRRQB5NSeMdyrhESd2VUJnYpkWcTchEguWbJOkuSkGR\nSybjFNt0cByH7twSJ88+xec+/5/4iX/yAp//3B/yyY++iIoKbh/F+IZB5YSIpKQ5v4yQEBUmXmsZ\nqxDsDw1S5fPwsx+E1hIv/OTzdFp1zp4+w/vCkNFen/v37lGUEXd39/n8f/hDLn/3u0wPMzoefPLj\nTyCFhWf7mLbF7eu3OBhlVAJC36cqMgQCkSdaeV8IgrrP3vZtkijGMUzGaUbNlkiR89CFk3zhDz7D\n7Vtb7B9sc+PWTYQ0Odi7wxuvv8RHP/QDfOSFp/nlf/G/U/dM/tYPvcDjj53h4DDFcOucOXeB8TTj\npT97mYXOPOKoZBL3UMogTQpMsyDPhOYuOz4KSbPZJHQ8uu0md65tUeQFw/GIer1J/96UcT/n7JmL\nvPvWbbZ2Djh7boPNU6e5dXWL0xfOaMuZ6zMYjJiMY3y/TlUlDIdT0kixsX6SZ56K2NvZJ8tjRFGy\nENTp5TGt9ZMAmLbE9Sx6hzuk0ymm7aJEhTJnUBsMWs0WV2/fxGiErJ05Te/efQ5u3KXR7fDCJz7G\n1Ve/y/j+HoYAZUqsSqvIpWlg2S52u0FteY5+71CPkA2l0/3yAmlaiJmdzDQfTLhm3lxbr6aqsmR5\neZlHH36YN9+5ium4RFMtlDNsW5P0LAvTgMnhfe7ffZ31U+/BXP0kYfRFyjJlkmpKWN4bztjY+gL+\nwA7qOM6x+vYB/76qtBJ5YWGBoszZ39/HESUiz0nTKXKkaHYbXHz4HI1gDSU1qESYJqYBvV4P1/UJ\nPB/LsYmiCbayGSdj6vX6MalRhwlVGIZJluXHlkIptQWp1zsijrS7pRZqS6IQBSsrcyRJ0y6bDAAA\nIABJREFUwuBoOBO+jTV/2zAxLajXQxzHPlaqj8cTkBXz823maZOkHYSocCwXIfJj4lie54yjKbu7\nu8wvLGFaejS/ujbH3/3Z/4Y4yhFWTrtdZzI44nAc41qmjowVguXlZWq1Gjdv3qTd6fDss88wmUww\nTG2v2t66S73hUxQpuB5pAZYRkAGf/eKX2TmYsLh5FuvKAWFgoUwD2wv5Z7/0L7l4YY7f/vX/C1VF\n5IXWM9iOOlaJl2VFJRNEocW4yjaxLBupSpqNrr4E2ZLRYEgSZ9TrbZSEIAjozM0zGuoO2DRMHbU8\niUnTlHbbxbIcsizWa1HHxfd9DLPJzs7RTJuj155zc3M0Go1j67Hn+fhBcLwnD8OQKJ4AUCJno/c6\nputSzmxtWnTm6VXEjrb03bh2Hd+r0Ww2yVJFUZaY1gPveQXKpCx1V91s15BSW35dV//ulpETZ3p9\nsLSyrPfwlaDVqBNFEWWZH19w8jxnZWXle66d3xcFvNNsIfIc3zQRWcxkMiCJJ0zHR3iWzc69Lbr+\nWea7LfI04eIjj7J15x5JFiOqiv1sj0oUrG1u8JGPvsh333iD3///PkcSxXS72osrlfbHmlJjSfvT\niDKD1y+9zdOPPcF//s8vc3BwwKc//WmO7vwxP/qJj/PQE+fotEMWukvMtWs8/dg6njlHWQrKMiOK\ndgGIiDC9nND3GFspk8M+77z+Fl59BKWHadcwpKIqIQxaeMECBhIr9MBXWMJBKIfOvEOzWSdJp1oF\neVSwfPpJ/uWv/Bu2btzkwtImjZWAJ55osNys85GPfYr3Pvo0jVaXosipN3xawy6jKOYHXvg0H1QK\ny7FJ05T+0Ygkibh286uMRkd85D3P82//n1/njTfeoDU3z6iM8W2L9kKLti/AKvADQ3cSwkZkExbn\nmhimj6wEjVqTcTSl3tDhLkLB3s4WWZJgVFBKSWDbTPoH5MWUT3/6Q/z2b/4WtbBFUWY89cSTRElK\nmsbc3b7Ln3/lZTbOL1JWkLsWh2nMwXjEzt1D0iwjLgrGSc5o0GPn7jXmux1AYrsenu1y4fx55rsL\nfOE//iEPP/YITzz9BG+8+SZ72/d4+PzjvPr1N3Bdn8tXr6CUR6Me8Oq33+CFD/8glqtQNly+dYeT\n6yvMtQPNgC8VqhI4dk6S9VlZm+fWtUMcw+XxRy/wnddeox7UiadjKpEiypKlM3OIIObRx9+DBCzb\nwEwNov5Ud7+z0SKGjlUFzcSf9kc8+fxz5GXJq9/8NoO72/z9//mXKPOMb3ztq5Bk+H4NFEjLpFQS\n03VIk5iTj51HOhZFVpAMx1DqaZFnWKRSZ7eDQkq9ODcMMEwDQxkgFYPhkEG/T7fdZmm+w8H+IdJw\nyRQYKBzLQaEQQmIZJrfffpmFxTP4tS7XRksk1/8Iw3EI6jWM2Y47DH0c156RufSYNwhqxxTCqqqO\nC2yr3eZOPKHTqCOTGAIPwxQE9YBzF08RZzFh4CMqzfC1bXMmhnMYDScEKw2qUrG8vIpSil5v/xjJ\nqceYNapKHHffD/4ujmOUUjO70pha2MB1fTIroyxznV4nJIGrfeu2qXfho+FER11WuhOsN0LSTHeI\nGumpyLKcwWCgcw2kwFSSsiiwTIewHlBvhDSbdZqNgDmnrXGgZUFZJTSaNfqTHvF0gmkaNJo+qlS4\nrsvJUxuUM+X+U089RbvdJoonhDUfx7FI05S1EytUVcnhwX0sv47AoJQO33j1Mpeu3MQJ6iwurOHW\naqRJynQcIUuBq2yixObqtbs8cWENK9BoaFEKDMvEcz3SOMGyDa1TqiqmkymLi4uIKuOoPzoOcYki\nnTQ2Gk8oiopJFDOeJDSbbVzXP7YED4e6AEoJeZ6wvLygA6GUzWQyYTwe0m53GI2GurBmGe+88w4L\nCwvHWoa5uTmk1J+7NE2RqjoOvaqHAYZtMRpOqNebx4llnufpszuKqNVqdLsm9Xqd/b3DGZrbxDEd\nZGVgY3P/7hbND51FlNWxxmI41EFT7XYbIQTNZpuiFKRJhu25SAyCRg1sh0oKrl27yvnzFynLkrW1\ntb8+KvTe7i4WimI6ReZTDN/i2pW3CcImlmkTuAbT8YBR7z4bGye4t3WHjZOnaTQc6kFII9QH7sLi\nHJ//wuf50pe+hKoU8WBAOhphOjaTSYbjgGtZnNzc5H3PPcHZzU3e9+wzvPXmJV57+Ys8/77nqMmI\n8+fn+aEf/kFOntlg++4tuq06liHZvXubaPwmtudhWBaqShHSxPY9nHpAmikmSUan0WZ+5RSnznXp\nTyakhQLlEEclEDCIc6K8oohB4rGzvc/C/DJX3rnMa99+hbKKidKYtKjA9oiLEcoyaeAjRcaTFx7j\nx86vU6PCUYLxcIBhCOKoh20qFufn2b13gIwnMOPt2paPrRSv/MkX+c6rX+Mff+urbMyFXJcFTaPk\ncHyPTChEKjEXa1jOHJ5fkRUJjufw5FMf5PrWHY1OBKZHE9I4Jo9GGOgkH6qcwDI5fe4Mvh/y9qW3\ntEhFKm5ev85TTz3K1vY+02jAmXObnG5tIKXg9JkFQreFJWt88H0f5q133uQP/+irrM7Pk/ZGCCcn\nLiWGYxMEFqvzG1iq4pknn+E973+W0K/RavpcvXqZV7oNpGmwtbvHK9+9hEojsqwgDOqM8owoTei4\nNapKsrtzSJqmnD6zxsHhgL2jCM+f4omItbMXCEOH/uCIp5+9gOXYnL94njvXI15/8xKW6bCwOMfb\nb17ivc99gDgfc+XqDbKJx2LQQAkPHDAdpW/whSbZ8eBPZaBm4p1SSizf4/xTj/HNb32L0c1taitd\nbN/j937jN0kO+wRhDYmiUAp7xo2uZMXZRx/lzLlzuGgxXDGeYj7YKxtS+1b/Cp5WN/36e8swwDQZ\nDYcYgOc6vPjhD7G7v8+rb75BIYrZakvMlPxgzSYHb33z93nuxf+O2uaHeXjJwJZHlIYi/CvoTcNU\nx2K1B6reBzauagZ0gQd8ff1lGBLTMZFVRavVnMU1NmjWwlkHWILV1GI4xydN9K73cAbPyDItFnpQ\n5B9MLxuNBmma0mq1iKKIZlMf5nmeYxiKtRUNQDFcm8AxyeOc4WEPz/PoNDQ0xMGkyrUq/YE/utls\ncnh0oDv0sfYcT8Z9oihjaXGZo6MjsiThkUcexrFNykJQVDl+4HJxcZHhcMj1q++ysLBArVnD8zwC\n1yKJTALXpSwkjWaLJErBUhpWkqaEYTgrfPIYmBLHJUWREU3HNOt1RsMx7baB5TZ49dUr/Nbv/DEf\n+PBHuX7rJr/7O/+RStlgglIVnu1Tlop7WwfkGfhem0m0g5AQ+B7jacS4f0S302ZhcYXpeITre9y5\nt4XEIisE03iscx8si1JAVpbcvHGbpaUl4jhl89RpilICBfPzXRzHolYLQOokRsvxAe1caDXbDIdD\nLXgTJu12+9i9sL6+zsrKClWlQ4KOjo7wPFd3476GylRFQRj6SFEhipxa4GEiqYrqmBpnYDIcDei2\nNPJ4c3MTJU0OhyM2Nje4ceM6zUYd3/e5f2+b4XDMfHeOSTQmSgpc18XzPHq9HmEYopTG3WpHQoRp\nW9TqLbI8YW19U3vT04zFxUWm06nGwn6Pr++LAp5GU85sbvDqtct4juTjf+PjfP2br3Dq1EnMSjId\nD1lfX+H+3Tt8/KMvsrC8xDRNqbIMUWjpvhIl/d4eu3fvsrmyhJA573/uEdbX1+l0OjSbDephjVOn\nN/X4UGhLl+u6NJ69yEc//Ax5nnPr1i1+6qf/BoOjPrffPsQxIBU5mcip1eq0Wg0qDNKioO13qKqK\nw8OUpr3Of/WzP4PtNKhbEhF2+cp3p/SzEUlaUJY6VDuJcxw3JC1yKiX5+tdfoSpKnn76aUzXZGII\nssqmOX8KWVVgmXTtFpUTQmTgJiNuXrvG73/2c2yePUkWHWIGNZQlsIyCZs1keX6NOCnwOjZB4FGW\nBUYp2Nl+hy+/9Hk++fEPcW/7Nq9951sYpsm9vW2EUWJWJo5lkoxjVGFiGg6GBT/yt36c71x6l3s7\nuzQaNQ52D5CVQCmN6ERp+I4pK2qNNo8/+TjYLobnMBoMuXB2k8WFDmkaY7sNrlx5m/29PZCmHqF2\nVrEtwbVr1wj8Bt2FeYajMYHlUE7HVI7J+z/4Xu7eP+DVazf4H3/lV2h4NdLpEEeVuGaJSAWNhkOS\njrl3+Sq7f/ESZtCCrEKaNpbrIdOMqpQsrHbY3hpgGXUCr8sHn3+BS+9c49a9fdrdU5SDfbKs4uHH\nznLn5g7N+hJXLm0zHPc1MGOSMhod8MTTj3D5yiVMqyIvIiqh91peK8RrLJCV4Lgm6SiCKIMgwLBM\n7JlbNc9LTbnKM04/dpFRHOm0sprL3/mF/4Hf/Xe/weGNLbBt0jzDVAbKNpHNkOWVJVZXVzn7+CNa\niTuccO/mbRAK2zIRSlDNiiUonTlvmMcFjVmSFSZkRUmt3mB5cZ7JeMiZUxu0Oy3+05//OZWYCdct\n85g7r4DpZJ+9rddYOfkcu87TbBZ/iihixom2cJWlOPZ+27bOeX8Q//hAxfxglO3YNp5tYRsG0jDo\ndltYlsH84gKNZoDnaQ613p97TKMxpVCkSYZQcH9Hd36mNXdM23tQqKuqwrIcJpMIz3P0qNkwGA6H\nCFHRnO3sj/oHuK7LsL+P69k4rokQBUIaVFlOWVYIqcN34jimd7jP8vIyaZoR+DXCmk+z3sB1bTzH\nYmneo9tdoMxzVpaWdKE/PNBjZ6WoSslkHLG/d8Ti4jJraycoywLXtSmrnPWVTaIooVbXRa7ZbCKl\npN/v4/kaVmNZ1izuU3ePKEW7OYehdHiN79UwlJwVeVDS5td+47dZWVngycef4PKVmyRljOMCVYZj\n2KDgi3/y5/zAs08gZzG/d+9t0W53SbKCFV+PqgcjvQO/e+c+d7d2OHHiBIZlY9supSg4d+Ei9+/f\n48mnn2J+fpHDw/4sVSylrAT2+C9DSzTYqsR1PYpSU+0eEMtsBxzp4Dj28fpBC94KyrKk3+8zHo9Z\nWlrSl0SrTi3wEWWKgTp+jxrNlv6ZqqJeD0nTGMfR9rk0TWk2GriuztNYXV3FtFyKSv9+NT/g3vYu\nzXYXZejn9oEaPsu0rqPRaHDQO6Jer5MWBfVmg6qUuL5W2k8mU5TUF+ejmVXxr00e+PkzZ6nXarhe\njbyEu1t71PwaLhat+QU63TnevXmTxXaDL7/8ZzzzxEXOXdzEa2XkUYLn+OzvH/z/3L1nkF3peef3\nO+/J5+bYEd2NRhoAEzCYwJyTRFKURElUDutV3JVlBUvLrbJsl11eV0naXa1Wkq2VLImWZIWlSFOk\nSA6HccgZkjOciMEgNxqdw833npz84b3o3f08+4HlW4XqL42Lqu6L87zv8/yf349K0eJf/PqP4Xke\n7miMpmnyBphEjPs9cPtcef42ZtEhTjJKlsP+9i4zrVn8YZfdnX0qlQq3n7+FH/tMMpd6tUYtg/2d\nA5YWlwmUmEq1ydzKChO1TqZYHITrPH+zw83rY16+/hyj/j7jfp9EMZmMtlFMmzxOUYRKnkqurzbF\nSWaxbIf9w2c+gdBU8kzh+KkzxIpCNJmQqBmqWMDNVMK2QT1pEnf2uH1li9F2l2989kmOnVtl7LpM\nRiPIclzPZ+J7pCIljeQtjySkWHJAmDzx5MucOP0YZ+6/l6985au4YZ9f+xe/ysF6h6994TEGnQPM\nTEdEJmfOnKG91Obq3/8NpVoZRcu5/8H7+JVf+mWG/RFJJnc29/Z2ONzbww8D+v1t+eFXfCplwebW\nTTa3MpJkxKg/IfICDjf3mK2XqdQt8ixjtmDxwFsf5I/+8m/Z2zmkUbL45Q//EoWCgxuGGGaDV258\nncc//Rgf/+Sn+fmf+z68WAWzxSQMKJdsyvUGzZk2mVdk7LlkpLhxwo07t5k5VuP21h1WV0+jaDbf\n8e538cK15/jrv/srZgoFev1d/FzwrcsuJ1vQ2bE42NoiVxRevvYNcm/Ch37og/zpX30WJUtQBOiG\nXM8aeUNWVpe4fmOdcZKzt7PHW/UyQQxBOEEUDYrLs/i9CUom0+Cx72HqOmEQ0qhW2B30ePz3/4y3\n/tQP8cDFC/yff/AHFKsV3vujP8DCyhKGYZAmGcPxmFHgM3HHxH7Af/zDPyFzAykoURQ00yLOM1B1\nFENIQcxdMFKakedScIIiC0kUJzilMp/67GP88A98H6qhEwQTKayJMzRNB8OAVIbukjyZzjQdNm89\nRbV5AooNutp9zGbfIi0409S5hqrKwh0HoUwVK7lsTWuSo59lKUXHJnTH1EplatUKRctEVRVG7gQv\niFE0lW6/z2A8ol2v0D3cpVIto2sq1XIZ1w/JYgtDKOxtbYGQyfe7hVoeJkLK5SL9Xlfu7GqyQ2AV\nrKN2u6qqEolqGvTHE3RV7i5HgU+xUMKfuEfz+1q9wvwxqdE0LEu206MAVRjkuYJpFBiNRjiO1J4a\ntlTwlupVVEXutt+FvNxTrTEYDnFDHwUYTFvK7ihAoJApIZPII09jqtW6LDKui6aqcgRhWjI9P+jR\nbLSxbRtNlQFK05Aq1gSF933gOOv7PQ4/3mNvbx/D0EhSD8uUONY8U9FsCz+e8LHPfpGLFx/k7KJG\no1VHVRW8KGYwmfDi5asoisrCwgJBGPLwa17LeDxmd3eXYsFG0wSNWhtDUzm+vEL38JD1tdskScZM\new5bNen1d0jSDERGsVTDshziOCRJAoRQECLH80YST2voTNwIIWSpajQa/wUvpNmqI1TY3LpDrVaT\nmN2R7LqlaU6OQjxF796dPeu6jiJSJm4P3VAII5fJBAqW5APEecyNmzflxoQIKdZKXL21xuLJZa69\n/ALlUh0v9kEoGJaJXbC4dfsmluUwdIdH++HuaMRu4mMaNr7vSwWu72PbFq7r0mw2X3Xt/LYo4Jom\nwe6KahKlsLmxhYLc8zbtEnmeIvQhX3/6aWYrNi89/RW+53veztve8CDucIjQLRbrTaI44cala3I+\nZsmTl6HriBwMzSTLMlr1Kn3PJU1gNAkx7AqaVcFLPUrtY9ilIrnjoYyGLJePkSQJmzuHFBvzOMdO\nEKsltGqDq3sd/uxv/4Lnnn+FwcEuaTRAZJoMFgkDU9XI9RHlUgNilbSYoqkKSpYSpQlJmhMnCSgy\ny6RqNlkqufDra3c4fuoE9WKVkR+ixxFVTUcNIhSRUBE5btQjj0q0yoKbV57ELDqU7RKaorK82KRQ\ncijZBrZdYnZmnsWVeV586SX+jz/+C1wv4ff/4Pdo1yoYScjrL9zDp/7x71m/s0e5YvLe73gzlbKF\n7Zisb28zNzfDvefuYzgaMZlMmAyG/Nvf+dc0m21G4zEISVzK1Yw48EmjEG8iH4JxmpBlKZV6BctU\nGEQhem7gDj3e/fa388hrLtDreRQUEKqJU/oUut5j2AkYDWI0K8UdhORFj0atiWEVuXz1Fv1JRKqq\n3Nkd0u3ssL1xi5OnKzTbLTYu7VNzHLx4wOoD51laWkBdUnFHPrub+xxbOsGdO9t0u11s0+Edb30X\njz32H/E8nxDoHPZ5+P5HuXCvzae/+HVWl5bIU8HgoMPsTJuNW7exbZ3xcIRjCTr7BywvL1AoyFWh\nmmmSTyEuUR6RpDlnT53jha8/TRyFKEJB2CZZIA9zt27cZGt3h8UL5zlz71mefOKrFJ0CP/qTP8Gk\nO2Bnb5der4/pOEzGE5QkA6FwsLNLFsWSGZ/mKLpGKgRKLrnPSp6TC6laFUxvz/nUPZDLGbyqaaRx\nSpJm7B0csDDfIglSSuUqjlNkHAQIRa4J5WkitaFCRxUqeZpz6Zsf49F3/DR97R5qyRamOiIIAkzT\nQhVyD94wVdI0I5u2zsNpG1pXVeIwkn70qTN+f39fKkSLNmN3AiLHMCVByzZVWrMzTEb9Iy52Eudk\nqSZDoijYpimthVXJ9i/aReI4PNJizrWlsc+2LEbjMZblkCjZdB/cIY5TVGFhO4Wj3W8/jIiSWJr1\nkphKrXk0ww+iUJq8kgzT1JmMJ8y221Ky4fsUCg65UBi7EzRNwwv9I0UmQh6idEOVRUlTqNbrTCYe\nupGhipQwTVB1DVNM4SIoFItFVEWgKJKdocUykKWIlP6gS7vdJgxDtna2qdfnMSwVRRU8cO40f//R\nf2BxtsXq8gq9XhfXCxHCBgRhDGkuyHW4enuN+1bOsb+/i1WqMXR7rCyvomuCHMHBwQFJnlGp19BM\ng4XFOXRVwzR1/PEE6aTNGA8HJEmGgk6lJAUwcsVMp9VqSH+4H4IixwNx4mFZFp1On5mZGRQlQ9dV\nDN3G83wmExddl52bnHS6Rx5TnGYaTNMkySRx0HIcPF9qTtdvbzAz28L3pcdiPB5jmiZpmuB5LjMz\nK9xZu0UWy9u0KnRMR2Ho9rH1ArZtst/Zp1C0MbEI0vBIdOP7rtzpVgXt2iyR75HFAaapoqk5Seyj\na4LBUAJf9vf3CYKAWq326mvnq36H/wqvDAU3jEmEimqbeLGH5liEqMRuSpLHmGaBD//6b2BlHqfm\na+TRiKuv3MayCsRZjBt2KddrqKrDeOiRDgJOnDjN3v4Bo9GEmZkmOTGDUUgUpJw+sYibaFTac2ys\nbzHwI06fO4uBwpNf/BqPvuW1HLx4mUqlxuGMycwjj9JNBV5Q4qtPXeKzn/s87ZlZyo0yBUdnb0NQ\nsHIGvQ5Z5uJFCfgQKNJ/LQLIcg10G4SGbehoOkQJCEVFywWqohHlKqGicGtti3tOLJNOeih+gJII\njLsJ4jxipmDS62yyOnM/P/zL30vZMnBUm1TI20XieXjR3ZvFmL3tG8y2i/z0j39AkqWKM9gaLC+s\n0hv3+c3f+d+x1SpKmHDvfQ+ws7vBfr9LnCaoWYk3v+X97Gyv8dQTTyLQGAzknrg3GUCWE6QxpAFC\nkTahimlz4sRx5uZnmJ1ts7A4z5eefoLN3a+iVYqEg0MuX32Zc2dP4Hb26Ct1DCujXa+xtbZDqKV8\n49KzfM/qD2I2UnTLYHlpBj/x2Ovu863nrvPSi1cY9uQ8qz/eQS+/idWTD/LkU3/HwqlVao3zVKol\n+v0+Bxt7NIoVulqHpbkW23duY+eC/qCLUjZYWj3BtadfwG5abK5lLC8ssnXQIclyxh2XihIwHkyo\nFm2uhBnF1EBkOaamUTJ1VtptooOA73zPa3jT+97JtVTeguyCjkmDl9duEfsBqi5IkxByUBQNtISN\n2zfRdJv7XvMQ1y5dYX5+gdXVVT7xdx9ld++AYH8PtV7h3e//LnzPY3t7F00ohBOXol2Uc2pVQa71\n5uTkZGkmaX+AgsK0EY6CQj79TGqKQpbl6LpKkGVsbmyxstTGzQRB1uCh7/w1nnn8PzD2uiiGChko\nmoZQBWEekaU5WehToIOrtNiyXsNy8jmKjoMiFPI8gywjjTMQGkoqsa/xlIWg6zqqptEf9ahZOr1e\nD993mZ1rY9smg0GPXhhgFxycgkkYQD8OUBUbyMgzDU3LCfMc09SZm5vj4OCAUqlEt9uVIo1ZnSgK\niWOZPvajiGJFho7aC3NSPakaRwW5VrP/s3l9SpLE2EUZONM0jX6/J7GfloWmi6NAnmnZcmuhVCBL\nwSmWCcMY05a7wbrIMXR9inoVBEpA4MdS6mKXiUQynat7lAsVuZsdJ2gqRwl+TTfkCl4UMPR9mWIO\nE7LAm8JtQDNVhiOXieehGBaqmNDdGyI0k6ad8fp7j9Mbx0TjEamwSPOAHF9afXMLXbXxRi7PPP08\nH/6572NnfwPdNKii0dvfoVouYemC4/OzMq0feERpjGqopPlUbGNkpJlUPRu2YKbWwjId/KBPpVKm\nVD6FIiRWOolTFEySOCET0lToulKikiQxoJDGGd1RTxq/4gjLMuXPVDfodvoEQYxtWeS+gjv20DTZ\nau90OtRqDcpVm83tDZI0ZzhwmYwj8jxle7TLmdP3Up0rc6uXyXVBEdPvHaLp4HryvQxVIw5CdN1k\nGMX40RhDN4nCBC8MiKKYer1JliVEvofjFI9a96pmMRwOiUI5ry/YOo7jkCQJQRC86tr5bVHAEeCO\nRyiK5MOurNzDndvPocwKRlHIaDRg2Dngs5/7Msm4h2PC9/7g9zHSj2HrJdbWt0lxmLPb5ApMQp3A\nC9m7MaazP2Z1eRGjvkizanL5pWeYay+RC5MkGnPpuadJ44TjS0t0t9aI/YDlk01G4w4pJknmML+4\nwiDSSaotXvzWN/jExz/GBz/w3fz2v/rfeMtb38Jzz94ky31SYXDs+ArNZpN2q4ltOczMLMiwSaoQ\nphlPffNptnfuMBp28AcuTqWJmhtAjm4axEmKo2sE4yGdtdsslApkSoIQCUqSoOsqKQJVFTimw+hg\nB8UzcCcp46hPpOTkCLRM/mCzTPpxTc1CyRTOrJyR6xmqgUpMEPXJ8dB1gS4g8UO6kxGthUUeee0b\nqTfabGxs8OQTX6fVqGCXLenfjjNG4x7+cMRMq8F8tcl9952l2WxSqdQoOpI9remCIPCJogBTV4gT\nH1stI0TO5vYdMiGwS23OnXuYPFOoVdtk2SXiFO698Ajv+a7v5d/8u4/Q6d6iNasTphnhyOX62i7V\n+hKG4/Lww4/SG2wzmQy4tbbOuTNnuLm9QeAG3Lpxk1rZwuv1OTzooFk2OYKZ2QabW2uYtsGzzz3D\nYqMhwRlJwuVLzxL2b/CZz38WBdAsh8/846f4fz76l/S//FUMAWki16YszUZVDOZmWqgaCC3ldRcv\n8NLLsmi26iWe/NY3ufPsJUShKINahlTQppMIUMgyhUKlwsbN28ydWOapr36Vg5u3IIyhaDJ3+jRv\nfMdbmZ2b56XBs2xdvzbdLc+k5UiBfErVyoFcUWQ4SQGSKSgpTaQLXEGm6BRBkmekYUyxXmWiqmxv\nb6NkD2GoGpOsAIrgwus/wNe/9BGSu38XhSTNSLMUTdUQmoajHBBmRSKlzEB/gCWrQ6cAAAAgAElE\nQVTj+tEDKk9TNKGiaZKeFafpf+GZzpJU5ikyFcuycV2Xrc0dgtCjUJDgjtHExbIsgpKNQsb8bAvb\nNqchNQV7Gibq90cUCgV00yTN5bMkCORNKY5joigmCGWoUtM0slRBU80p2StHvWsPhCNphmx3J7Kt\n7brT9HkmNa1CRUHB0CUOtNfrYZkOOwe7OI5cY8tIieMQx7HxgwDfl7vMjlPA90M01ZgeegWO4zAY\nDFAVjU7nAMcyjmhx7dY83W6XIA4I44BqtYo3liQvq2DS7U5Q8hRTN3B9H8930Qwdf5JSKVYYjCec\nOXmCh+6/h2888zzPXrrET37/O7h5/QaFYpXrt7bYOxzgBhk/8xPvY2WhwTe/+U0KZZPBYACoLM4d\nmx5IQvQ0pN6oECQxYa9L6PsUnQLFQoE0kutShmFQq9WOkLqqqhFEfeI4lYYuBIqiUSjqDIcBWSo7\nO5ZZwPcDPM+n4JSIY5/BoE+WpUez53waqpQZAEgVFVQDRQPd0HD9Ce1GizCMGPb6nD51iihMOHbs\nGMPhGMPQaDRqjL0ho8jj9nqHmZlZ7GsOQawhGCIsC5SUsT9G6EIeSBQV3TClungahtN1g1F/QLlc\nxp2E1Ot12arXTPq9IY1Gg35/gOk45KiomsnS8urUG/DqXt8WBXzkeezv7cvF9lzQG7koisK430Wz\ni8Q5CKfAs6/comjpLCzM8cSVPRRhMxoe4Lo+2wc79MZPMPHGJHGGqlWpV6qYhkbtxjbnTh1w7tQy\nC7PnaCwvMupuohUdzrWO0ekc0Gy1GY89KvUWQQZb231KlRmGtoleLHHYnfCVx5/GCfr85m/8Elcv\nv8Jf/8WfUKlUJChCCHqDMbVajVqthi5kUnU4HNPv99na7jLxfc6cD3n9295G4I3Y29rgi5//Irkr\nec2JkxPmKSgxpqWSRT6OUSOZyMNNqqX4cUCqQDwNUhxbWCGY6PiTiDAIcGMf13UJxj6kkQT9Fx3a\n7TblchlFiSDWMBzp4jUsFV0YZInAdFSCMOOVm9ep1WrEccqttS2C6A5FS2fU7TMeDqmUCvijCXa5\nxP/8m/8T5BmOI/27aZoTTmUL7ng8ZRHr2KbJfLuJLhSUPMcwLC5duUa5vsDiuXv4wz//GzbWblGr\ntkgSmZbePeiy3xvyr37rtynYNg89eoKf+2c/yfVX7nDl8lUeeeS1GOQ8/9w3iTOPwHcxRcZo2EcV\nYGkOxYLNjSuX+a73votPf/pT5GrGsD+gUakQ+BFO1ebtb34j7uEBBgper8+157+Kmg548Px5vvbM\nJuE44s76Og9feIBvPv8MaQIFW8PSdLQMDjY2Obk0y6/+tz9Csazzja8/B6WH0bQcS9OJwhjhOBIQ\nInTSPCYLQpRMMsxt3aK3s8mpe05w+cUXObixxvF7znD8vnOsHl+l2WoxGA3ZXVtn4+pN8ALUFKIw\nksUbJBtGrnvL1PkU9AJSICKrbz69jSNv6Uwd6r4nrWhZJgUpaUo6naPqxTmEoqFrOaSQkpGloKk6\n5KDpKkN3SMXZpJuf4lA5STnawco6Mq2t65DJPfDheHwk4fB9H00IlCkBTC0VcN3xlNIFJaNEoVCQ\nSWJyaZ8qlqmULTSh4PkT4niK2MwiRqMJtm1TKBRwfR/DkGAWRVElwtLvo6o5mmFhOw5RlMgZaZ6j\nKJm8LZsmOzs72LZ9tOJz1444Go3kDm+S4oaSIGYYBrZtkmUwHrs4ThGA2cVlWYhVHc2wCOOYTFGo\nNZuUwoTRaIRlWZiGxLlGUUSrNcPW1hZ7e3u0Ww1sUwa3NE1FEypCQLvdpNPdRzegUS8hlESqWCMo\n2RaCTLZmyw6kIdVanaIu0Awd0xL47oSZusmZ1SbvecdrOLm0xOHpeSzbJlF15haPsbN3yPLiMYq2\nA4pPoWxTLDq4bkDJkclwzVSJ4oSt7R1m5ufIc5hMPNrNGfI8I4oS8lyZ/hwD0kSuMNbrdXp9eciJ\nwgRV1WSYz+2j6zq+HxLH8jCjCpMw9I92u+/icKvV6lF6W4pKEiqVCkkm0DT5J45CWo02mqays7VF\ns94gcAOpmEXB930sqyLhPW6fcqHIysoMV165iSp0xoNDvMkIxTFJEh/HLBJFGfV6ld1JD900ifwQ\nJVcwNA1/4mHbDnku2N/vUKs1iSL5eapUqiRJjm0X8L2QYeLJQGN/8P+fAv7gxdeyWVtj7dY1uv0e\nhWKRleOLKGlE4I/JFMHpCxdRhEav10Eh5+Of/QoiLjAadoniMQvLTc7efxqhqcS54NatbW7euYap\nm6RJzjOXLjHbbLB8bIH777uX43N1irrK+HCLW+s3adRKTAYDrq2vQZZADG/7oR/gxOoZarMr5Lsu\nF9oRp5ZV3vTGR5hrlPjjP/u/ubOxzXgwwR25pGlOr9M9OrVrmsY9Z1c5ceIErYVlolRQKFXY2xuR\nJBHF2gK/+mv/ks07V7l14xrr62vYCJIwBNejJDQmW3ewdMEkDkk0nUyoWI5NEri4ox7XNmMuf+wQ\nkavouk6pXqZUKjHbbjHbqFCv16e78BmaoaMgbyNxJFt4Sa4QpymjUYKlRdimxd7BAWPXRcVAVQ10\nXWN/f5vDwx5JGGKUa7QbM2ys3+HO5j4nT64yGPZxKhJ3a1rFaYvURgjkTnUkkZKtWoVhN8MyS0R5\niOq0+Y3/8be5tjGkWdVp1FRqtRp7+z0++rG/58JrH6DoJLzrnW+mWNDY3blMQddp1Yt87tN/w8UH\nzzLou6CCaTmUqyX29vaozM1SKJrMzbXJg5QklOtJu3sTfviD7+cv/uIj1MoOrh/gjoYstBuUVEEa\npkz2bjLxR5hGgbJtcrCzx5c+8ykefd2DzLWa6KZJHIdsrN/in/7ED7E832S2ZtJ8/f1UZ1vc3s55\ncQCapqClKaYqyDQBiZx7okjPvWrLVmA0cXHsMuOhx3xzlg/9659i0h+gpBm7W9s8//S36HW79Dod\nhoeHaJpKmqQye5DKmLgA7iokUnIQQopcNIHCVBCU5tOtAVm4hKZCrhBGMZbjoKUZQlVRFI0MY/pu\nCstnXs/1lx9HUw2ZZCcnCQOEUEkFdIdD2tUypWCPsTLHZvYg8/4/YuoCbXqLTRWOEJp3lZKGYeC7\nslBWq2WyNCYIfIwpazqKAprNOqZtIQToagZKTrFkAzIIlGUZmmqQptF0JUyZzpcl0MOxzGmIrYxm\nGNPZp41hgW1a+O4YgEqlQhQFVCoVbNsi9EPsgjNFwSoMBj1KpRKB55OJqUBJV48gLtJcJn8DrhdS\nrTQkLtT1KBQqjEYD4ihHU+RNTjqxQ9zJAKEqFIsaUWyh6zNEUYRj62xubtKsNxiPxySZNSU4ehxb\nnMP3JySExGFIpVwmisbkWYpBijfsMddsEkUumZFz2B0ThRlxmHLm7ArvfOebqdWbTNwBtnWRKEwp\n1Zps7u1QLhdJ4pgkCVlYmmdn+w66quG6LmmikAsVXZfURT8ac3AwRlEsykWDKMwRCNJcoVCQIwfb\nUnBdX3ZdDIeC3UZRcqIoJo49dF3Dm/iUy3cPXBK7m+f5EcXtrlUsyzI6nQ4LCwt0u11GozGlUgkh\nNHp727Tbs1RLVfb2tggUhf3dQ8rlIn4c0en0mJ9fJApjKuUqiiI3JNJcY2e7g96aIyNnfn6ete1d\nhCkPl7btIJBdniCIyJCCoAyNNAcx5YsYmjyglstlqVrtDajX60cHj0KphBbGpL7L1s42pmke6VRf\nzevbooBrpsG73/ceqsUPcunSJR77wudZWF6hd7DPi69c476Lr6FUb7Fz2OXZK9cJJmOOtRs8/MBF\nPvuZTxEGQ87f8xCrq7NUGnU63TEP3HMfz73wAl954ilsu0gUx2wd7LHTOeDpl17i+MoxTsyvEA7G\nFGslZk+c5tSpEmff/n6ahRpKHLObjQl1hzDO2N64TdGIUfQS//bf/RF/+md/Tm/kIxSVLFFQshzL\nMshRMS0HWwjiOOTy5WtcvnyNSqvBhQcf5Z6zDzI/v8h44tHrdbhy4xZLC22+833vxXcnLB6bJ41S\n9FwBN8Tr9filn/8x2gvznDl/jvsfuMhwNOHrT32N4fYOW90hP/yh91OpVGjUm9h2CSGgYJnkqQRL\nRIl8YASjPiDnj1mioBs2YRpRrFaBjMnEw6wWSKKUWItIspTxqCsFFVoAaoRmanT6XWzDwrBM/t9P\n/AP//a//CqZjYxoaeZLK3WMEIoc0jfGnekBVVVg81sKfDAhDlSjJ+ZXf+B8oOg3q7SoFMyeOh+iG\nXE/zXY+9nU3e9tZHScIxV9Z2SJN98kSwv73FQw/fz9VrLzPTXiKMAwzH5sKF+3n50jXiOKbZqlBv\nFHnLj/8U16+/hKYICib85Z/+IYvHVmUAJcq4efM6D73vPTRqZQY7faqNIkv1eVy20I2c2FeJsozj\ny8ucWlmiYuRceOACZ07M86Hv/w688QGdziGtmUU0DY4vOiiDlCBQGfcVbl+/iRImoAkS30fVBGmW\nkEbJdJ0rRbUM/PEEp1bmmae+wcuvXGa+0eLal79BZunkR5pODZHJwp1mmbxxZznZ9GYtW8CZTKWj\nyADb3fQaHH1VhEKW5hi6QZanBHHEmeMroApCNLkrnqfkisrSyUfZuvkkkR8hVIU0jVAyGY5Dgd3t\nHc4ur1BiFz+vyla68QCt9EUypBkqSSVc5q6zW4hpS9IwKJSKxEmE606mCNUBhqHRbNap16uouka3\nt0drrslo0CcKRgyHQ9rtNpVKjb1dOfeOIvmQT7IUS5EPR6EqaAiyPEUROa12Az8IMHSDg8Md0kha\nwZIolAVQFzi2iW3a09axPHg4jiORr50OTAu3H0wIQpdyuSItcXlOEEQgDHxPwVAFSp4xHvQRIudg\nb4dKqUyWxGSaTHZX61JFunb7FSqVCoWiCm5GkgQ4joHkOGT0+nIFbW9nl4Jjyxa655FEKUqWI3II\no4jA92g2m3S7XdqtOTIlYOJFFEtVECnt9jGGwxFmMWJ/5KJ5KYbusH7zBrqukpFjGjaOJdv5umEx\n8TxMw6ZQLNPp9CiWa5J4aFnTw4Z0sR/2RxRthySOMUwFVdNx/ZA0VymVqvR6PXTFmM6WwbQMsjTC\nMg0Cf0KGRPuOJmNZFHWL4cilUrEI4kg6DqKItbU1LMvCMAxAsLd7QLVWwQ9d8DIyFdwwQLWLZEKV\nK5CqzuVXZMB5bqbN5uYmJ06ukhNTq1WYP3OCzzz2JTqdCapuYTgFBoMhhumQpnLkErgRwcSnUIxI\nErCtArql4/sugf+fZu93xS1hKNvpewcHFNOUQqmIqmsMen3mZmaPxgCvqna+6nf4r/D6D3/87+n1\nemRxyumTZ/iuD3yQ67ducmt7wCNveTMnTpzhC19+kuvXb1KuVHjdax/m2tVL7PYOGIchGFWe+sY1\nNvd9FFXgBREmAtUwmGvNE4QhSTghZ9oiFIIrr7zATH2GCw89wsnTp9B0SNOI3mTAzfU1tm5scfGR\nd1MrFPjoxz+KUw1ZPt3kbz/5Ev/4iX9Ay21qTkky0g0ZOElFTJopsk2Z5QjdpmAVJbu3H/Llx5+g\nezBg8fgyp8+dJY7HHD++TNUu8+Kz11FVwZWr2wx8nySX0AyBgq/rfPdPfYjLN65ydeMaX3v6OXKh\nc/rsecKXb/LIxUcIfA8lE0RejNB1Jr5sX2eZZGXnaYJjlQiDCKEIhC2lA3bRZBINKJYVSmYJ1/dp\nZwq/+PM/z7//vd+ne3hIlkecuXic/X4XxbBIoxjHtomHMbc3brB26xoP3neeXmdXSloySJLsCNYR\nJXIOGWkpy6uL3Fkf0B+PmHgpcehRnmsQRn2a1SaKonLhoXOY1jo3b+3yl3/6dxiWzagvV2fyrMN4\nFLC+tcevfPg3OHHzIsEkoVK1yUnQLNl684OAD37P+1hbe4VqpcDcbJPxOEBVDN762ofYHkwo1arc\nOXDJBJy9/x4KVYdst88jb3sHjgObByMsO2V/oLAx9AjTlKVWmXe//l7+m5/9GVZW5tnb2kSoMblZ\nJNGL9Ae7xGGHBSVgK38TW1sK5x55Hc8//hnQwEqkZCTTNBQdCXNRYDzuMLPYZHvjFvaew3gw4Mra\nFrmuQBCiGDqqrpP4EVGeTAfcCpgqqExvzgJVU1HyDOUuNCWOkVq//zTDvvvYuNu+tm2peVR0VVoB\nkZQqKzsgExahUuPCQ+/gycc/hmrJ2y6AKjTIUnzXI44jRJ5TSG4y1O9loJ6llG/j0EMXgvw/m31H\nUYSqKJimidAUTFPHsgzm52cZjvrMzLTwfZcwCvADj8RNgQzf90nTnGNLi7Tbs9jTDsbs7OzRLTjP\nc3w/xPVk6jvyPTnjzjNCf8JkItdLTUOuKJmOg0KOpiu0Ky36oyFBEBBFCeVKicODDvVm42germka\nfhySpzpkCYZp4o4HmKZJ6EcoSo5j5QSBz2QSyByIpuCYFrXSHIomzVwqOYohIE8IfZ9SwSGJ5AM/\nT2WbvV6vMxgMmFuYlV/n5mg1WiRxRhLCZBjQas2w3x2SJgn1ehNHTwhTlSAJ6U8yLKtIqWzQ7w3R\nNJ1bG3tMxmPGQYqwHfRcJUljTFuTBxfDlnY+s4AbZlIsY9ukiVzP0gyTw8MuuqkSBD6WZaGbOq7v\nEsYBqqqgKCrDkUeWS1hKnMTs7MoRqe/tTwltQ5p6FRAMR7sUbBNUBaFrNGr16b83BqExHLsYtiV3\n7m0L3/fpDYeUihWyFIrFIofDHoYliPyIOE2xrTK+G4Fu4Q47uF7EXqePrkqXxvLycQ4POsyvzBOO\n+gThiDB0OTzsUKq0MewiA+9lvDRFpHL7QEkEZm4Rey6bB0PZIq8WGHsTWvUGeQ7r6xusb2xQLBZp\ntFropikBMcpUFqPruK7L5uYmq6urr7p2flsUcEu3OXXqfkyriGMa3L69zvyJe5g99zAl2+CLn3sM\nfzzi4vkTxLHP4c4Gjcos3b1DluePkSbSV3vjlUvErouimbz/gx/kzOmzVBsNmo02plVEVTV8PyRJ\nEiajMXc21zl0x/ivXKZULmMVLPIgpjl3gh/50X/C5x77a3qDQ+47f5yvfe45XvzMJW5sfon5kkV/\nEhBqEhRgqToi09CVIooQJGlEo1FHMw3KBYeZmRl2OweoGXQPe9y+/BKjzh6qrrG7doU0zSnaFoHv\nkmag2TaGbuI4Do1Gg1/42X+CH4z45GOfpWg4pGhYjs3gYAOjGuKNxsRZgiYAkRDnGn4So6VTWIIh\n069aJndfyTLyBExdkGc6prBZXmxy51afarnA1vpt6hWLQkHF0FW6nZBHLj7KSy/folgwGY0OaZRq\ntFotxsMRv/cHf8gv/uzPsnRiCaGb6KqOhk6xXMK0LQxHhpP+4fFPs7YDx1bPUSr3uHF9ndHuBrtx\nh8wNGJkltLJgp3OHSm2OmZmEvb11mpUWrYpNs97EKVR4/qWXUVWF//V/+S0eOH0G349JcVk5ucDb\nX/d+8hQODvvcunyVt7/jIl9+7Jsk+CwcK3Hrlk+rVqZQUFicabK13efrX36Kb7zxQd7/nnfy0qWP\n8Gf/5k/QCglnT9/LO9/wMH/+0Wd49pnneHJ1kTTs8cY33c/G1hXSyCUYZ+wfbGFXSrx09SqjA5fu\n5gbH7r+HarHGwLyXduUhvuu7LT75yY+jOA4gUJOMTAnIUSBKKOkF1q/cIEkifuFffpjd8ZDbL13l\n3MX7aLVm6bhDur0eWgp5khKkEWEUM+n0cF2PyWjEqD8gDSPyKENkOUo2Ja+IKUZ1OixXpipSFIEQ\nClEco9sGa+t3WJlvYlZOA2CrPgVlh838IdTCEncxpqkm09CRH6GrGmXTmvLdc2wREeW7+GKernqe\nYv4k6RSukqfxEdAlTROSRK4fJklCvz/EMnTq9TpxHGJZDdnRymSyXigFep2ARq3O5p0OaRYyPz9D\nFMvUr1AhzWJUVYJPisWizGMEnpy7xzFxllKYht9IYqplhzSWB82SU6TX7SJUnciPiCIJiTJMnW7n\nkDCKqFarVGsVyndVmWZCHMq5eLVVIbIiRqOR3CfWdMoFSXBTVZ2NjQ0JjSrb2FYBU5dAFCEM2vVZ\nBr0+hq6xs9HHMHSEYlKrNSiVKvR6PZIkYzAYoeSyk9Xtd8jJubl2jZWVVaIoQVMN/CRjNHapVpsE\ngcfhsI9p6riRx2JzAcuyqNVq2KUy46FLs1rF9SeoqoOm2fRHHmkakxoKqm5gaAZxlpGm05XXJKVa\nLDCajIm9EEs3yRLJC6hVG+iaxtj3yIWgNxrRqNd48fmX8X2XY8cW0AyTcRzhpRGb+/uUiyVsq83O\n7gFmSWN//4A03cc0bWzbplpv0e13SDPB2Juwd7B/5JcfjUbEcYqum0xGCZ1bfU6dPo9jFRjt9yGP\n6BzsYzkFGqUZZi8u8cILz9IfuiwuzjPyfJLU5OBwwq7/PK2aw4u9A6wopdPdJx2PwK5QLNUZKvtE\nqkNequLFYyoNCQASmqBUKnFw0EUTBZr1Y5TqEu4yGI1RVI00TeXnOs24dvUGTqFEjqDXH77q2vlt\nUcDnF8+yubdJ2B9hKDqtlXmu3rxKFhmcOLXKPadWmHntRf7pD/8oeeTikdL3Y5QMVFWiHSejIQcH\nB1y7cZ13vetdNBaWWLt+jRuvXOWJx77I8898i+vXr5JmY4SIUZQF0qyPksfkwpEIQCXHbs5y9tQJ\nnvrCVX7kx97K1tYLPPvNb3BzfRslzyk3l8izhFJdozo3B7lATVMcTe5l6rpOnmVsb+2SxQmnjq/K\n/fOSA0CtbCOEKne+hYJHhCAlDIaULINGq017bpE7m1t0D/cY7t7GPLmAI3SUCHJbkMUZBDGjZMT7\n3v1WxsEYPwxQppIKcikeUHRp09EMFdu0sAwTNUc+mJwiaZ6SGiqKU0IVoGsmqohJhMVXvvx5OWs0\ncyIEZ0+dJstjwmBMGOT4XoRmKWArxJHgs5//Er/3gd/FtC3QdDIE7mhCr9vlxs0NnnvuOb515UVU\nu0CW5OiqQa1sE0wG7IYBpjKmVtfZ2+hQqAgOtrYYHQbYBTh57mEax+q87sJFFo83CP/wz7l6eZdw\nsE+5fB//7Bd+Bnd0yMrCDJWWQZBNKAJPffXzmGaXsq1TKC1g6CUUMWb99i7Hzx7j7LEa33o+Iog0\nOltdXv/GR3nkdadYWGly/vx5ojDh/W95J685/wh5nrKwvIgXFAgzn5XFU9xe2+Lxx79EhsLy8RUs\ny6JSqZCmCyy1FimNn+KKqBPo80TiOKfO38PNtVvTnWedLBOQxUBOJgSZGzOzvECr1eTlzdu8+wPv\nZa97wM2dOxweHuJOPJnoD6crXKlkC6g5qJpGsVLCG05QM0iiGEUVsrBmgCKmPPNUBtBSOU9O0wTd\nMNCEShJ5uG6EVjZkaz4eYGU3EOb9GIUWpdo8nneIYWqINMXWVWzDYL5apWY7TPwJmRBoigznKCRk\n5Bi6AGGRx9Pd6UDe1HTdIstki31xfgHbtnG9IZZVZ3d3GyEsOr3uEY61OWVOV6t1kiQgzxUOD7sc\nX66QTPd3R6MReZYyHo/lylUYHqmKnYJDZ9CnWi5LxWMkDzZ3fdRZnpNEAUJAmMQULRPHtLANqbB0\nhwM5X4ejYJXIwdR0vPGEyWSC4zhsbm4e7Qjruk61WsUwNGq1Cp7rEoVDZmcLEtyUQ3c4YDiZkJFz\nsLfP0tIi9VqVLIN+f4iq6uQptBptxhMPRVHRrBJCCBozkidvpilJGAEZrWYNwzTlKK1cIY5jysUa\numZi13VM0yAIAkqLJYIgwLaKGNN8QKFgo+Q2QhGkZPihj4pClmcUbFuOCkgwdQOjqjOYuARRgut7\n0zGZymg0olQqkcYRqiKYnZkjihKajTaKJqUkvf6YQqGAlWvomklr9hi5nmM6sosymUxIFUEUpwy6\nY2xHdi76/T7VavWIfuYHIUVNh9ykWJlnbbvL0pzBJ/7q73jNo/cze2Ie3/UZZBFJknDv/ffR6x7i\nuREz7UWqtQajTo/9UOfOzgFn7z/Dleu3KZeLdIZjmRWYeCjC5KWrGzjFnNOnV3E39slSn/5gSJ5l\n2KUyoasQJVBtVKb/X326nSHNZos8GzI7O8udO1tcuHBhGtrzX3Xt/LYo4IowqFTrMk3ohexubaNo\nOiWzhppkLM7OMR6O+N3f/31WFmaIhKDVmsGyDEpOAce2KReLmMeWmVs8Rnc45rln/1GSigoVHnnz\nm3jwDW9A01SuvfwiT3zx81y79AqFclkmf3QZRBn1DnEnXb71TJ9vWR1euPIiFy/McfGRR7j34ddg\nKoIslRacudkmf/J//RGWLrBMgySMyAHf86bmJtmWu7N+Q0pUFNm4zBVkyC2eFlslY39vi0cvXuDc\nPae5fPUGTz7xBfwwQCWnVaty69YN3vve7+AX//nPo1sFnnvhJV589jmiJGM0CdBUm9mZFlmWYBmm\nZO7GCeQJUSJVf4OxTxBISpCS5/hjDy3NiNIEw1JpVMpci7sYikWS+EzGAWpukKcpuiY/oIpqIFQL\nzfTJRIxp1dle30cVOTduXeWlF1/h5uY6O/0D9g8PiMMIbzg+0jjOtmbY3N8lzWJ6wyETd4hQTD70\ngz/E5asvMuoHOJnPm1//AF/8/NcZaxHDoc9v/c7vMn9uCWXkoRbg6199mk9++ssEuSCPAwwtZpz0\nGQxCVKuOKgmhWKrBO978BjQ/ZH13iO+NUQ2FcxdOszA/w0svX8bSc4bDlBvXr/KGN7+ed7/tHezv\n7FJyClhOkWq9wvLqSayCzZ2NG9iVEqqn8fLLV/jCF75AFIXU6w1i3+WB++4nCRNMo4wXQpammGt/\nQrD635HqFVaOv5FgMmB/vwdKSkYiZ81IhrfimOyvb3H16lV0ofKnH/kIjWadxtws3sRFVRRKdoFU\nNYiCkCgN6HcG5FFMMJHBqjSJEZkcvyRZhpJKSInsuCvTtHqGIgCk4UpBfpc0ATgAACAASURBVL8X\nx5imRjqdHxMNSTIfO7+Ga93L697xQW48+wkOD/YReU7RtJgpVXG7Pdav3eDY6jEmYUKolkBAiYNp\nGCnENGwSRbaghbBQFIUwDCmVKrI4ui5CSGa5rqs0GjK8VZiuXxmaTrHo0Dncp9fZo1wpoOpFVlaW\nUAREYYDnJywtLRFNk96eF6Bp2lGBHo/HVKtVBBwRBA1NxzCMo7Wnu3PJNE0xVE1GDNIUpj51XdOm\n+8U1Dqc757ZtTw/tW5w8dYobN26wtLTEaDSS7ueRlJ94nsdhp8OJEyfodg8ZjSZkCrRbM6Sp7JQt\nLs4ThiGqqJIkCZVyjTAMWVo+ThglGLYjV+Cmv+9ioXA0LjAMg2JRzurDMMS2bexSBdd1QWiEYcjO\nnvydzMy2cF1PHnICGfLSNEG320XoGtVqlUGvT5xJmqNt2yTRhMgPqFWqCCHQdR0rjdjf36c9M4Pr\nSrNYoVwgSiJaMy2SJKZYqwDghSEGBv2Bx/LKaQ4PD6nUmty+ep3FxUV63RFbWxtyBXAyxvM8Wu0m\nhiqIR9LlXS6XmZ+fZ3NzE2MaLCuXy/R6e5w6fZZnXrhEliWcOHWSldWTTHIPwymwvXXAyZOrFMtl\n9vb2cH2fNIMIwfLxEzz9pWep1Nt0uwP8QBr0TEMliQOcgkEYFfjxn/4wAO9822v45z/1/aiKhjsK\nKRYsbMsg0kI0IWmaeabguh5LS8eo1+vSEre5ycxMG9/3EKJAp3P4qmvnt0UBP7Z4nNPls5w4fYrN\nm2sEyRhvPCH2E578/OOsnjjGxu4221u73H/+NKfOnmd7Y5NRHFMQOtu373D+/DlOnD3Fx/4/7t40\nVrL8Ps97zr7VXnepu/a+znTPcIbkcJsZkiJFUTZJyQJN2VogJ5Fky3CkWHaACAkQG0EQJIgQA46c\nBEgUyJIDiZQocZFJURtpzT49S3dPb3O7+/Zda7u1njr7Of98+NdcKchHfiFcnxpoNNDddc/5be/7\nvN/8Grdu3SIJIsaDMWQ5zZU1nLLD2uYGH3/+k/zaf/Mv2d+5z6/9V79KnsSgjSmVyrhKQZFIBWuU\nPuSwJ/jGNyZ8+9/vc/byCT7yQ0+wYGvEcUh/tE0+G5NqBUGckWeCfI73oygQeUKaZozSGSgFqlDn\nLwfJJs5zuX4fjfpcOHuKj334Sb7yla9w/8E+3aMRtqNRrZSw1YIvfOELLC2tcng04fXX30BRFE6c\nOMH21n38WUQcFUymfdI0YTabMZlMpGpTyPWk5EFr5EJgO6b011omrm5QqldpLlQx3tDwHBslzlFU\nGAyGmIZKHseYhuQ/nzixwYP7u9TqNfxZzFNPn+Of/PIv8e1vfYuXvvcyv/PlP2AWB4RZiOvZVEtl\nsjTGm4txjjoHXDy9Qa93yJ3DbXIV+sMxeA5f+vlf4S+//V1e/M7vSvFHvULn0Eeg89atF9m8tE6v\n32ZRczi1uUx9QeVonPLo4S1mkx6WlhDNAkSuUeQZlmEzHAwQUcCkf8jK0joXLlzg4d6bdIczTqyp\nPPH4JX7RrTIezfjYlfME05BzJ04x2Y+o1SrYXolGc4lJENM76mKXXfxgTBEqZLHChz/8YZZbNaly\nLi+AyLmzvUvnaMCDnUc4tmCx5rK58HvsNf4BwljnylNfonrvz7j37rugIVeiqopQBMUs5COf/wx9\nf8qf/8HXeP7HP8/p82eZjsYMDjty+slykjAhz3OiWcBkPMYQiizUyAIuFIWC92AtUrdWiOI45KSA\nY8CLpknBYRRHLC4s0FpdpRPJCbziFnjC46Te4Z3icYTV4tOf+iR//JXfl7f7wZTIz1lYWaS/s0e1\nVsaqNkmR4RBOcSjv3ppCkqQY8wSvNE1xHAfXLc/XyCpZkTKdTqWyXGSkaYwQOWmWUC6VOHPmFP3u\ngWSUk1Mue3P+9Yh+vy/FcF6Z0WhEHCZz21mZWTg9DnLRdR1N0+h3u9TrdVSEpDyq6vFqfzgcSuVw\nJG2JKgrVapWSKwEvSRpT9kpYhslkNCbU5RTl+z6Li4scHhzQarVYXFw8Zl0XhcSmmqYp161Hkplt\nudKKlhcZzcUmlUqFOE7miVeCPBPMZjItS1E00ryQNkxUTNs6FkrV63WZGjaP+HyPt22aNnF3IGNM\ndeOYVNZsNknijGgWSZtXmtHtdmmtrmC7JaIk5uCwI7cymczuDsOQQf+I9dUWhZIThTP8XkBrbVV6\n6/OCVmuNLMuYjGUKW61cZr99OPe3j+dgkxoH7TGvvn6DcqmEP0vod/bY2d9hNI7Y398ny1Le//6n\n8P2A1ZU1drYfUnI91lZPsLa2JnkFika5XEVTLVRFp1otk+Yxa+uLNBbLXH36STTHoKSbLK21mGYK\ni0stxqM+pVqNwWTMysoGpuWw3+6immWaqy53H+yRazrTyYgkSdne2WFheYlpGKHoLpbp8dIbe8w6\n/xv/9J/+Y1bXznDU2ae+uUCWdxBFThLPEweBu3fv8YEPvJ/xeIzv+zx69IharcZ0OkXTNL7fzw9E\nAQ+jMZ3hHvce3CaLYhQtkx7bTKHZLDOdjGi1WjTqCxzuP+Lugx1EMWE4m+Jis1Rpcvudd9DLBsPZ\nlB/+kc/x/qc/xOvX3uTe3bvcuPYKyjAj9gfceesaRa7y/I/+MP/6f/1X3HjrVd6+fp3eYEh7v83M\nD8mTDB1BZXUTrVGH2OPhwz7X/81X0ZUYkaeIZMKzl2rMxgMM0yIrFNIM+UCmGUkqKTtJFsq1W6EA\nhQR5oJHnsqvd3dnnU5/4GHfu3qB/dMh4PJSqYaUgiiQoYDKL+KNvfIe9gwNM1yROAopMQg32Dw/4\noz/6OppqIJQCx7Wkd1TXUQ2VSqlEs7ZAo+ph2yaNeo1qtcxCrY4aZwghedNVx5OipkxCYo6GRywt\nuSh5hmfpmLqBaxoEQYJjlJiMZzJMoDfAdjye+ehH2X64h6YW1F2XIsno7XcYD0c4ho6SZ6ytrfG3\nPvtp/vyFP+POozuAimlq/Ok3v852x+fi6fNcuHQJ26rIl5YqcYmv/9V/4HOf+CG2rr/Orh6zsVjm\n0tkVXnntkO3dHkU+47GLa3T2DjGEQtmzGMYKewd97t55RF1NyY0ZpzdOYKpv8+brN1lruHiOycc+\n8hS25ZFOhqiKynqjhrnytLQ7CXj19Vc5Gk7QTQPXtbBcC38w4OyFCwzGQ1RdYeSHjP0Ove6Q6zfv\nomoGhp6gKoLlhRWuLCs0gm9y2/wREuqsnf88mfIn3L3zFkpeUCgFIklZO3+KKx99huvXb/D8T3ye\nD77/GR7uPuK73/oOvf19nEqVRq2OoijkaUKcRLIwFArhaEwmcnRN4koRoCmKRKcCCEldk+pyIWls\nRY6qCpIswTJ1wijm/v1tnPVLABj5FKEItGyApxwyU1YYhB6PX7rIay+/TlW3WVhZQhQ5pBlJEFG4\nFsLUMIsRSjYFQ0UIjTzJEJp8qTmOpJYlSTL3+cq168rKCv5kOleox5TLHtVaBdu28X2fo6MjmvUG\n5eU5aS0/kHZNRWXmx7SW1pjNZrJwCnnfb9TrjEYjHNsmzTL63S4qGkkkN1P1ep12uzvPlbYY9ntY\nlsVkfMTq6iqKprH14F16vR6Vivy76LpNEIVU6zX29/fnfnVJ13Ich9NnzhxnnWdZJjcAmkqOIAgD\nWq2WDB9RleMXeRiG9Pt9bNsmjhM03SVKM9I0w5+GLK9WSHOZLPieDS1NpG1uPJZ87yTPmA5n0ka6\ntk6/38cxpV0pFwXValnmo2c5cRhSq5blhiQIEVkuiWf9Lpplo+o6jisbolK5RBTMWFhqEucp4Ugi\nQeM8Z799RMmrkmUF3d6Mfm+ArqSUKmUevnKdzlFvXtR99nZ36fTl9zsZDjlz5gy6ZtLptHE9m2Z9\nlXPnzs2thhlf/Edf5MHDLdmUBTFBmHD7zruSkW65aLpFuWrJxsA0GI37WLaFqgqqCxX5HOjgz2Y0\nm01ycvzAx3YMstxgOpuQpAXbOwdcfPwj3Lt3j0pjgVJ1ifbBHrNJQhPJ7683XapCxTRc0rxg5B/x\nwouv0qyY+NMe9+7fpb4gufGmJnkC9XqdiT+l3e1SKdfQDZuJHzKazHBdl8bC8vddO38gCnghpggR\nEAZTDENjEkZ0JxPi8Zgwljm+tiOD6j/w9NO4DZ3d3R4/+fnnaXgL7N4/pHM0ZLvbobm8yte+9Ze8\n8NoO62dP8cHP/QRP/fCn+ZPf/x0O37nJYrOJV/H4xu/8Fr17N/mRH/0MP/WzP0O52WRj8zRpmjOJ\nMiw/onB1Jqj8xr/5v3nz9X2WlzbIixhdAy2rMJt1SKMZ8XhAJvT5HV0hy4pjxeo8fXGepgOKIkU0\nuSjQDQPHM6kvNHmwfZNpFFCoGmmcowmdLAfd8Pjmt/+EslfDsGyKLKVku/T8DpPJiMUFuc5qNGsY\nponrWZTKLqdOnKRar6AIUBWBbWrYliaBMEXK+KiLo1qkWQy6Rtn10IsCMo1M1ZgGY1qGpLdlmeDR\ng4f8k1/4z+mPcr7+tS/z0ksvc/fWQ4pCYDo5uukQRQF5FBJOxwjDQDFdrNoi8WCEk2rcu3advzyx\niLloMUkTNGFhGSpVVfDwnVvcff1lvvP1f0d7/wH/6n/5dbLkBhrwzrVrfO2r/wfR0T4DP+L06QZP\nX1rmuy/skygu129e5+qFD1B1XIgMGnWP4WRAb6xgu8tcPrvBUTClVjYpWylxMGQ4PAIlw8gyxqqG\nSUG93iQMh0ziEEVReOvN6xwdDeWKfJwiKlXWFs+xvlzh1r13iBONICh449oNojigVqtQMTWazTpP\nXL3M+uoilg6RH3BKP0Tv/wZbiz/NRCyyfu5HmcwUeo+uk6YhiqbwmS/9BLZh8/5nPoQwNL774gu8\ne+MWAsHTH/so9XqDIsvp9/sc9ftUTemrnvSOQClAUchFLoNCciHXv4WEt6iKoBACTVHlcCAEqMWx\nJz3LczTD4J0793l6XUMjxbUURKqSFYIqW8z0FSbFAhsnTrK7d8jB7j7PfvBJ3nnpFRxNJ4kSMBsA\neHkHUzfQNCCXW6d0jivNcwmX0fUcVdVlopNpMhgMiOOYarmCoVv4Y580Dtnq9VB0lc21VYbDKY+2\nDymXK4hi7uu2DUSWsre3x9rKKu32AbVajZk/YjwYsrl5ku3tbaqNOqZiMB6PeXjvPusbp3jjwY25\nCt5m5gfkeULJdFlbkzd5KYbLsV0HIYQkiAn9WFF/dk5PW11bYzweUy6X0XWZZX18pw1DdFOeJXQj\nx7BMyVA3/hqrKd8XJqZpoWkmURzRqDfpJD0m0xnh9rYM68jz+dZCmduoYDSZUiqVOBr0WVxcRFVV\nZrMZju1iOTbdbhfDtqSPuzBxLJM8jphMRjSqDSZxzPr6JkLRcJwS1XqTIApRVQPDsImjjDRTKDea\nhLOAnb1tdN1kb2+P8cQnDGMURWM6nVKt1Gh3e2iGgVBglkRMxhKyM5v6rK8sUi2VOf+pT/PWm2/Q\nbrd54okncVyDituQzWmeMxgMePBgm9HIJ81UuoMxadrnlVde4ZOf/CSPPXaJYF4bjsYdTMNmMpmw\nceIEk2DEYq2BP5mg6prcPNgWo0GPpcU6KgULCw1msxhFsVlfX+f/+do3eeONNyjylMl0hkgzolQ2\nnFmWkaUpRRaRZikK8OEnL7K01OD2jdd5+n2XCUKffm/I4vISKxvrWJ5LHKc899jjhEFMrmh0jkZc\nvPA4ve6QJOnwzDPPfN+18weigN+88Q65os9FHTnL6yeYjUI6nSO8WpUwjrBsh2qtggp8+IPP8Lkf\n/xBrFZ3f++0/ZDqSNoWokAaYzeUWw1jl9Tff5q17t3niygW+9FP/CY9u3eR7f/ZtNM/DpOCVa9e5\ns9fnIx/+AMutRQ72v0IRh5jVRYos5MbrL2HYVazGKnbVYqbMcDWNMJjy5KVTdO7sQAFetUaW5fOQ\nSOnaOQ5byOQ6LEriuQCmmAP4BXGaMgsS0A0mswShWqR5TIEqMY+Oy9CfUK6WMHUIQx9T1+h1ukwm\nI2xHJ04jPvaBj0mutKFSr1epVEp4loUgR9M1dMtAKDmJkpKLDEFOWnWYhDmRkqKYCsWCi1GzGR1M\n0cycKEsYDCMmfsH6xjq2W+HhvTavvn0DU7NYarYkulFT8KdD3nzje5TNJU6dPkF3dMTS6VNM4oK6\nV2Nn9DamVkCcsHvjFh//wsepqwa5ZhMWMyr1Er/y8/8QxxREwzbRaMzZk5tUKibFMOf2u3syiOSw\nz7lzF1haWOLs6Qmet8U0Vnj5ldf525+8RDAuUBWVU+tLbD8aoJuC7UdbXDm5TBhNeP/TF3jqyn/L\n+sIyi0tVoiCQdrZETsuz2VTe35KUPC0QqsKZM2dYXV0jTzM8V+ofCs1kFuTUG0sMBgdsbK6RJjNa\nK3WqloOumETTkKN+n+VWAz8ec/niBU6kIc861/jK1gn200tcfvJvcVBbZevmt8mTiJJXZjiZkIiC\n2VAWn9bJDVqtZfIsozccE/kzoiDEq5ShKLh3+zakOeTZXEQkPc9CSJgLigBFesKVQt6+lUJQFDk5\nGbqmgVIgClAVC8OW90pLDZiOhzKoQ9Wx2UfXZmSKR6jVOX/xIjuP9nnhr/6KZqGQpjnj8RAPDwAv\nP0DVQENDNTSKXMHWZfPqOBKRmmUZipLOY0KlUyGNE6IgJEsSjo56uK5LFEVsbq6TZyqVyhL1+hq1\nWk0ilic+49GUsudwuH9AvVohnE0Z9NssLS2RxCH3t+6wu7tP99oRSyvr2LaM5yyXy7z55ps8+fRT\nGIZGueyRpTMqJY/pdIpuGmRFjuO5VGrylux5Hmki5KYtnw8Xto1lWZRr1f8fitUwDDJRMJnInHbL\nkv8HpmkymUxYX19nZ2eHIodKvcp4PMV1Svh+wGAwkrdtyyJNInq9I0olF9u2qdWq85jKiZyGY0le\nEyjESUIyJ5T5kymmaWJoOuEsIoszPM/BsW0JmokD4iwnjzJs26HT7hFHKb3BEa++/gqgksQZluUw\nOBpjmjag0ukcSpJZMGF1rYVhaLz/g0+xvrbC/Ud7rKys4Dol2u32/HxXsLa2hqVIElqlUuGJKxcZ\nDPpoeoGiCAaDPtWq1EQ4jseDBw8ol8ucOnWKarXKuXPn2NjYoFKpYFkOsyhEyVL8IOLqY2cpleX/\njWubCEWlVKvPA2UMHMdjUhQ82NrCde352Ubl/KWn6Pf7fPGLX6LRaPCVL/8uo9GELE6IRTEP8QFF\nyk6xNQUVeHfrDrfutFho1qiWK9RrFRZXN9jfP5yTOXVKnsPufofDgzbj8Zj19XXWNzfJioLJZMJ4\nOv2+a+cPRAHvDwM2Nk/LrOAsJoxUavUVuuYuoijQDAs/CClVyrz51jV6k5Cf/4Uf5Y/+6Bu8c3eL\nWnmJvEjJwymqrmDaLuQ6DcdiMB5z7aVr3Hz7Fs899xE+8zM/T63qcebkGpWVk7z26ps40ZhiOub2\n23/GwfZdTK1MrEE1S6jqUypamZEwiAwVkYEhYroHO1jlCmmosNc+pEik2jVNcgoEYRihKKCrMvZP\nVXWSPEWdE6lU3URVVdbWVwmDBCEs6o1l+n3Jb9YVE11VsU2NkqUxHvdJ05QwEwwHA/KiIBM5mchR\nRIqh6TiuiUKKrhQoFFQcmcyT56kMnyiK40xaUxToMVQ1hyjKaZgOCgmqLpPbhoMpq8sb/Oo//2XW\nNh7j9//kq4z6PpqmSNpQoRAnPo4psA0HsyjwxwH9oyGKodHZOcTSPRRfsG67VFWF5y9+ipWTdZqG\nwclKmYMjwSwTHPZ6PH52lUcPbvPvf+87lMtVDDFDUxI0zeYoHqOpJucfv4qS+BzsH+GWSnheiB8X\n9LsKtdom68tVhsMjVqpVFj2FM+dWCacd3nrjRY6iKeVaDS3T6AmVR7t32FjdJEkK7t9/QBCFlObZ\n1bbjEccx506fo1AkW9ytVAmClIN2m0ftEdv379KoHDAeDvnQM0+yuXGJ1kqTu1u7dA/7PH75cRaW\na2zdv02lVOLB3h7bW/d458ZdjNIC5z/+S9xL38/qyfdRqbV4+7v/jvtbWyxsrOOPJ4i8YKm5gFp2\niOOEIs8pV8o06w2yMGLUO2JvewcygYa0/ORzWIquqOSKTCwTRQZFDsp72e2yuQTQVRVDVSkQKIok\nAJYWmwCYYnZcjMScg17JtxjoTzDKamy2ljm9ucnezg5rK4tMEp88LWHgooicujXGMGQCIIVA0aUG\nRHLHi2O++HtFcOIHNGpVpmMZiWtoGo3GApVSmdksZDoN0bQZb77xDmfPnuXu3busrCwyGPYwdBVN\nF5zZXGE6PiKOA1zXYWGhyWF7j8PDQ9IkZ7nV5OoTVySDXNWIooDnnvsYiq5hzvkBlulI1bdQ8JwS\nE3+KEAqg4nnleUSpnL5B4jw9z2M8HsuVeZygzWNHFVUwHo8pVSvHUTKu60riGFLsdHjQwbE9TCMn\niVKytCDRMkqVGlEUUalUCMMQ34e11gpxEhIFIX4goTVJJrAse85c0PF9Oe0qiiJ/7VZIJxP8aUQY\nyj9zeNDh4OAA27OZTHzG4ymzuWfdcSxaS4v0+110CiqVErXmAiWvyq1bdzg47PDEE+/D9TTpY1YS\nnnnmg7iejRxOIprNC/I8Mpuw1rSOc99rnqDdHVKkGb6ImPk+m5ubvLu1RaVeO+acr62tMRmPWV5a\nIE4SwnBGo1EjSSKeeurJY+LedDrG8iw211cxLSm863Q6uK5LteLNhXkGhqGyt9tmbXUJhIqum1Rq\nNaZ+xGQ6xTBMfvcrXyGOQ9bX1ymVpwz6Q/xwTJrkqIYEdVEopLn8Jp+6dInPfvazxNM+9YpLGIY8\neLCNWyqzu3PIhQuX2N054NSpM0yHAZ7toasKlqWzttbi2Wc/wvQ/lgKuWjpjf0ye55Rci/GgQ8Ux\nqFQdglmMZr63TjZoNJv0uz32H2wTDo/QipRuew9FgGvq6BSUHJvBKMU0XZ742Me51W6TOCVeO/TR\n9wZcOrnJ7rTDw2++zMHWFoO3XqSkCC5dOMdI1cn0lLJismmYuAbokyPMCGzbI0DHIKMXHbGyXAHd\nJMsFJddFmwc06LrOwoKMHFQ1KY7RFRNFFaiahuuWCONUCtkMeOed26RpgqZa1Ks14lmHNEkoMpMi\nDxm0x5iOymNXLvLmG7eYDEeU6zJbeDQa8eyzz5IlMWmekpGgKyqWppNmyZxMlWIZlqR3pUChEKch\nZbeJ749QbAOvbCPUDNUs0FSTJA6xbI93H27xJ999h9zV8So2sZ+xs3+fwaSLgY5tWly9cpL27kNu\nv1swGQesb6xS0hyquYkdFHilOqqIMKKIF//iT3n+7zxPybPJ22OalSZbNx4QTAZcPneKuy99C9PV\nWajqNGsl+v2MIM4YhD4f+vDz+JMjXMPFMVIuXPpThi9vMRlN2N095MqVBqovuHjyNJfPX2BldY0H\n9+7RPjhg8cQaB/sdXM1gcXWJIpTr3P2dfU5tnkKzLLZu3aZ/NOTkqTLlxiLj6YQky0mdnNev3+Tm\nO3cwdIso1RFRzNWLF3ns7AlOra2hFtB+0KG12GJlscXq6hJhHJBnBcOjgIpTpdDqXL3yLI3aGsH4\nLldKY26lH6JUW+GDn/0l3n7h2zz7hSUc2yXRIjYWTmBqBgJBmiRMxxMOdvfY2XrAoNMjjxN05I1G\nKAJVU+cv9XQecCLQkOhWAFVV5kVdoOsamlAQeUGWpeiGQZqkrG+eBUBJhuiqjIRUFIU8y6hyn4H2\nOIlSI8gPuXj1MtPJgCgOsEsWmbsEQFnpIbIYodswt2kJBKoi1fbvISTjucUrDENcrcCfBvJeXAgo\nCsqlKrqu47kaYRySJjmNRpO9vT1UrQAlxrRUhkd9VtcugZJhWxaray08xyXNYlqtBTY21nAcj6QQ\n5Ogk/hTTdFGyFE236Q97LC23yPOMWZQQBj62KW+reZphOfYxt9oyTPwgJAgC4lgiWoMgmOcejKlW\nq2iaRqlUYjIdEccxehThui55XtDr9Y7tVqZpzrMKyvNoW4PlxRbT2Qyv5B0nndm2jWHaRGlGlisU\nQmE0ltjOLBcUc6Kd7weEYYhQFRzTYm9vjySVepvO4SHhLEIAtXqFwWiKV2RYjoubqzQXV2k2m3iu\nyWK9ytUnLpKGEaqhyS1IHHPxwjpCVY/xoFmWoRsGYTAljifs7u6wvLxMnKTkWYYuFPI4IRcFw+GQ\n4qGgWqmxsbFBFAQsNqsM+m1qtRpRkiCyXP6b0nQeiRoSJVIroWsKM18cix7DMETVVPr9rsQRJzKi\ntl6tEScZqm6hoDPsT6g1qiwutECoLC+vUql4KLqBYXoIVaXd7fO5z32B3/63v8mtW7eY+hG6aiCK\nHMs0yDJJIMwKgaLL5u6dd+6g6xanLz1G92BHMtqBzVMneXgvxzIcXNvjzp172LbN+sYSmgbrGy0e\nPXrEwaGEvXy/nx+IAm65LpmWo5kawjYxDQXd0qmvtEh3O+SiwFA1/IlPvbGMHsgudH/vkErJIc8i\nkrQAU6fQExRlxmrJIZoNuf/iI06fvkiuKMQZoGSEu9dR9jUqIqa+YoBzlVXNQhCz/JnnSHWHIojR\nwzGZljJLExYilSUMcmQXqygKWj6lSENWWgty2s7BsC2yLGNwdCSD43M58RaKikqKP5WqVc2QQQR5\nEoAwQCskmzrXUVSDVKQoIkVJM/7Zr/wyrpuw237AoNthb6eHEBqKAkHsUzKgNxmj6iqmyImCkESH\nQHHB0Kh4dc40T1BxypClTI76TI9mxOOYCycvc2vrTUy1iVcusbc3wiLFq9rcvnUD26gQFyrdt/b4\ntf/6l7n7YIsvf/UvUFwXJTW59fpdNuoGH7h0hrvvvsg4c7H7GUqusrNzSFlV+S//i3/M0899iN3x\nHv/Dp/4nXrrxAn/w6gsotkoUBHg1g9/49X/JP/jJv4NXN1FdjRP1fP1DcAAAIABJREFUU5w+eZK7\nu1uoIXzj69/izPoi1+/eoWyAlQr+7o99homfUBZlfv1//rd85LlLtFpVmksrnL64jlJoVBYqhKnk\n0i+vn0WhoDvt0+kLrt18kdZCkygX9LptTp06ycnTp6h7Dq+8+hLTWciJ0+e4eWuLm3ce4kcwngzR\nkyE/8qlPUrJ1rj7xGHkagkhIRUowO6RWXWbkxximyskzp/HHPpbpsVFzSNOU1soah/ttOnff5kz1\nkD334wTmKS48/WOM99pUagF33n2XB7ffZTYeoUSFtHspioTkGNKHrQHFe3AUVSGNUxRVRSnkKUGQ\nQSokB10IFFWRP6dizkAXmVQ0W95cuKkz9VOadfD0CFvRiJKcnByR5SjM8PQdZtopxnmNijelvraM\nlRacv3KZjnOREHBEGwxNnpCKHFVTUTJpmVNV9diyZc/XuGEYMh4MMRYbaIaOqeqEsxlxFKA6FmgF\ntYaNoVtUaw7lyiae55KkMlREVUEUKVE0YeoH7O3sUy2VWVpskhcw9bt0u20uPf4YOQpJ5FNaaB6f\ntAzDoNNps7mxQTidzEVzI2ahj+W4GJaFNm/M4zCkXC7Le7QQjCfDY1W93LSpkio5f0c0m4uMpz6G\nZWNZGqj6sbgwywQKJgdtuV2b+AMmDx5RLVXpbx3RWGhIC1jBse3OcWxpsQtG7LfltGlYOiIMyKKY\nLEvw/SlJkrCxtsF4OsEwPK5euXB8qgDZtPUOdqlW67hO6VhpnqYpe/uPJJ0vCqk3mzIkRNPRHAfX\nK8mUt2nIdDrmxIkT6LZkUzx25jFGowEbJ2SYSxAEFLaMarXncJ1mXXr1F5cqHB4ekiQFrdYqQRCg\nGDr1Rolut0d/0Kbb7bK41MS2DTRNIUmiuQAtp9Nr02g0ME2b9fVNFF05JvEZBaTBkPX1BsOyykKz\nQV7I50A3VrEMgzCOMRwFcGkurnPn/rvsd4+I0gJNh6yQTXCl4XD5/FX+6nuvkQHkKapmEoWCl198\ngVt2wc23X6Pb7/HFv/dT9A5NJtGA3sBEMQoWl0qsrG8QBD5ZHnN4eMjBwQHnz58/Zgp8P58fiAIe\njHt4lTIry+sYhsVBu89sKkhGY0QOhVApFFkIo3CGqgjqiyvY1Tqj4ZggDVE1E8XQMRwd1YAT60sU\naYZWgB9O0LOYME1ISciRN+goDBCaStWy2G4PyfOUaZEQKSaGIhBEKBaYho1IBaYIKGkQRRGGaZHk\nGcl0OreCFOSaQhDIjlHTNEIxZ1bnOZbpoemCPE6wXAfPNdHKJVrNU/SHXXq9Dn40I80dKDI81yRN\nYkquTTAZU2QFeZSwtrqErt0mnPgYromuQlDE5KJgFkRouo7nlmmVqiTrK9RUi3qhcf2Fa9zsDogP\nutAZM5z66InGC9MRhZ2z+KHzLBguW8UAwxbkaYigSprG9Ad9tKzAH7SpNAzJt1YVyGPCIEJkBhfP\nnaXsvkiYxOx32jz21Pv4xf/07zPce8TyyQp9fx/FSPjyl38LXyS0lpZ5sLOFMA3CQPDuzg5BnnHu\n1CnqzQUq1UUuXbrMd145wELQbvfxpzFXnnwfxD52FCM8h3/xq7/IsB3i+z5L6yUmkwELiy264wH+\nKKKxuECGJEgpukEcZ9y5t00WG2xunGBpocngqMd44vPiC6/w5JNP8jDwSQqH8088QbfT4/bNW4gk\n5XRrlcrFM5xaLnPhwgUEObquEs4iDENnbW0DlJSpH+NZOoNhl8GgJ1XXWczqyia94YjdR3vs77Qx\na01SBKvpCwyUIQP9SWKlxWg8o8wBZafG6VMX8Q/bWIbOzJ8SBTJtzhBC4h3VOXleKHKdrinzlK18\nHphhgpDTrwLkmQwz0TQVVdEwNIM8y9FUFU03UE05FWhFIG95uo7QdSzLwjB1mmKLGacI1EUaWo8n\nnnoaS6gcFCuENEEISqKNphqo79kq/8bnPevMe3GjpmlK/YZXYzj22VhrkSUxlqWxcmKN2WzKdOYz\nm/kIdcba2hpBHGK5Jm6pwv7+PqoKtUqJl1+8xurGOjdv3+GZZ54h1zQm0yFrG6s88cQVHu3tUK5J\nf/VB+5ACFcuVa+M8z5lNpriuQxJLZGupXJ/HRVoEQUAYzvB9XyagRUIq0k0bzRBkopC8bm+B4WRK\ngUK5VGbsT6UWAUiyjCAKseaCK8MyGY+mOHNvd5InlKs1gigiSmIe7jyiVq4wPBpgWfLuXa1WQSmo\n1+uUy+XjKV5TBLNCkMYhrZUVdF1HV3QCI5jHNM+FZLOpDMPJczTLJkMw9Cc4joNm6AxGQ0zLQtFU\nllotDMMiTaW11DAsDg96RFHC4lKdrMglDCgNyLOELCuIZlO6uwWaIYWUUZLgOA5xFLLzcJs8XiLL\nEsJgQjgLqNYbksFeZDQqNUqeh2gKpv6ERr0OQBwl1CoV+v0+IiswDJ2N9TUazSamKQcmocoQG9ey\nSZWU2XRKnqao81Cb67duyXONYR9vgBzPo1rzOHf2BDcevMbP/uTf58W1TR5u3+Wgd0AQ9Lly+RST\n4Yif/Zkv8X/+9u9hWCZJHLOytsyLr71FNB0wHh1RqpT5w29+hxMnNlhabtJsLHPy5Ckm/pQki1le\nXuSou0+axGxurFPy3P94CvgX//ZneeGVl9m6eQORFLjlBoaiUtJtmmtVcqGQ5hnlsketWsFUFW68\neZvm4iqoBv3hBF0IkixHzQTT2YTJg9uIvEBTQUky0jAlT2N025iHzwt0FcoLDYIkYZbNpK8wVvGi\nHHTpm1WzAoOcIAyY5QlpJAuybblYjstipXy8NtNK2rGgxfM8bN3i1MmTEgpg22iqoFaTpn6hFIhC\npVFq8J3v/SEvvvwSd9/dJ0pyNEWVntk4QUVB1zRUQNdNev02URyCasnVvFoQZjFFlLG2vMbSxgZG\nUGANQrZfusONd+7iP9on6owIogRfpIRqRq4U5LMcITTQDNLOAa0zi9T3DzFUnSQSxBEIrQChYesw\nOmqzfvUyGaBlOYqAKI0ZjwIufOJ9aJpCluWYjsv1O7f4hz/zd4mPHjKdHqDYEY8e7VKqlmiUSpxd\nO8H3/uom6Bq6U+JoErG73+fEss72g/tYbp9avYxnK0wCQX/oE4ewf2uLmqni5Sl2ucwsS2g0lqg1\n62QorK+dQQgFJfXwqg6Tmbwj9no9WguLdDo7FGnOxXNnJI5xfMT2/S2yRCIvG40F3mr3cCp17m0f\n0Nnf49OfeB5byfjoh58hTnNm0yFxkbG3t0+tcg6RF/jRlKVGk267TSF0Xrv9H4jTGIArV65yeNAj\nDdt0hxPSTKFaXWeq2wgUwjjBS+/hKlMOtQ+S4lFa/BAf3byM7Zq8a11n0DnErdYJkoQgCLB0A01R\nZVhDIT3gGgqqokiluRBoqoYgJy9y+fu65KYjFBRNQROCPEvkZKyZFAWE/pD6MoTWWZziHp5lU4gC\nTdVQBOhpG0sZEKsN/KKKWkw4UM+QqR6KyFgR19DzMZlQKeb+6vdWxu8V87/pj07TVHrao5TJ1Ofk\nSYNqxSaPY6Johq5rOI5NTsGjR4+oVCq0Wi2O5lPu6dNnGI56aLrB5atP8v73P83Hnn2eOAmZjkec\nXW7IEJCeZHDnQtBqtWj3ujhuRUaVxjFFmskbuGWQ5YJypcZkJqFMqZC0OE03sW2XJJVNukA9XqOn\naYpuWIwnPpbtYOoGlmXx4OE2luWg6vNErzl/fjqdUhTFcfJWFEVYjoliCaLQR1UVyq7Hxto6Jzc2\nKYSgWq0SxzFhNKNRrx4z2x3HksVKgG25FGlBbaFBr92Roq753f299LalpSU0TaO8sCxz0sMQkUrP\n+dEsoF6XTU7Jq1MgmBwd0Ww22d3dlavtZMZodMTS0hLj8REzf4DvT1haWObKk5e5f2+bwWjE4vIy\nw/aESqUMmUajLk8i5bJHksrmrbXcYnt7B93UIIfR0VCeSqqyeep0OiwtrDCdjtE0TYJ4VIVSqUQY\nzjAUcEwbVbcYdgesbpyg1+nimg4gp+5gFrK+IgE5lmGytLAAwKB/hCMibt28hukf8Du/85ts3z9g\nZbWKGY15+up5yiUQM8HXv/bHaJpCGsXyuzUdxtMIMoMgMQmHKRkjojhnb7fNu3d3ePJ9V1E1+Qy2\n9/dJ/CFnzpyUjPujPmEY8uSnvr/a+QNRwM+cPseFxx4nyzJ2H2yz9eghIi+o2x6FlpPmUqmqoqIK\nlSyNOer0KdQQ13JZqDeYjGdoGRiFhmfZDPsTJv4U3TLxbAfUggIp0IrjBKGr6JpBFmaMZ4G8byc5\n00lASXfIwpQwmGDrBuNxl8XFBr/wn/0CGhqO42CaOtVqFctyjl9O7ylM0yQ/Jjr1Oj3iMJwnF03p\nz9nVQeSjqTarzVXiWFKovHKJaRhiWRZJEqMpoGoGtuPIdJ+gz3DYo1Q2mYZyIyHygtNWhcZmC98P\nuP2N79K7v8vuW3eptaecungWwzHpNGuksyntwYSZItBJ0SwDMY92bKCwUHLxRI4fz9ApoRkO/qTL\nZJJiaXD37kMufeQjVGs1wmmEpsss3xPrJyi5HguNKt3Qp1A0xmHAb//u7/GPfu6LZOEQRdXITY17\n29t89Lkf4szJnHrJZOhnqEKn252gmxUm4y6OaxGEPtWKxdmTTd7oDxiNBJ2DfR67eg7SGDXLCMOY\nRqWOW3YpdJVef8hsplLkGlGYojkKvd6Al194meWlBmqWINKUz3/6M2i6hF2oqkprsUat2mBnZ4ev\n/uGXefKJx1lZaxDlsLpU5vTqMv6wy97hDo5XQtc04pnPxtoqlqFz8uRJAn/KaDCktbKJKBRyNBlH\n6VUJg4wTp1u8dec2hW6SKQpJFBFpOZZlUTI1hFqg633M7Du09Y8S0CRMqhjqiDMnzxFPQ9oHuyRZ\nwdkLl+jsHZCkMWmWIgo5YRd5TgHHgjVp1ZKI37wo0DQVoary7p2nc4uhhmWaJKlUsR/cf42VU0/S\nTVucLq8RJ30024Rc0twc26ZR3OeQBhOlRaGvI9AxxZSTyquo+QBNN6D460hdVZWF7r1AkDRN/z/w\nFM/zSIMCt5QTJTFrq6soRYaSF9i2zWg8RhlpPPfcczIMIpCZylmWMZsFx43BpUuXyLKMJE8oikxO\nS2mK7/s06jV2tnc4e+4Ct+7cZnF5RYJQopQ0zSlVKyRhRI7Aq5RxHE/eX7OULMvJspx2u02lUpnn\nf/vkudwobG8/OhZg3b//AFVVj5njiqJI9Xq5PH+uM8r1GvVqReJYK96cQpdimiqtxQp5o0ScClRV\np1wqMZuMKVBwbJMsjTFN/RjYVK1WmUwidFXl9OnTx66XJEmwbZfOQFru2u0OtVqNarV6/D1kUUae\n5TiGXG+nccLa0iqqJpuMJMsplUpkWUeeflrLGIbB6TMn5hwIGZaS5zmt1Q3yTGHvcEB9YQkjDFA0\nnUa1xtJik0E34/K50/SGE3RdpVaR2wTfDzh//jxJEpFm4Lol2ejkGVEUUqmUCcMZtufS6XcIooiy\n51KtlmlWa0RBSBzM+Is//2NJ0osjavUK3W6XUslFU2QKnGFouI5FECc8bO9Rsi2m4wmvvnOX2zfe\nxq6U+OlPXyX40AUs26C1uco7t99g98Dn/vUtGQ6UqSyWS9RrGv39bUxT4/Klc1w8v8Yrr11jc/UE\ns6lPtztgd3efvb09tLl9+Is/8WOUTIXVlSUWFhbQdZ3Dw8Pvu3b+QBTw/d0OhSrIiwxbh3rdYHQ0\nYBr6GJpOFPqIPCWJBagmhqGh5zFpGpOFGWqcYaYCQxeYQqDEKWF3RKVcJstVVGGSFDlCNxnOIqI4\nhyIn0FRUPQBNZRIHEr3qlujPAkZzb61qGiRxwY9/4kf45LOf5eHu/fm9KODmjTvMZjMZ2ZkkxLGk\nTInir6MdXcfBsx1mYczCogRBVCqLrK5tYJo2zUqDo7fvEKUJYRLPSVUC01DQVJUoiqQwBYNmc5H6\nQhXtYR8RCIRQSBWF7M4er9y4zdbde8TjgNQP0FWdv/ff/Qv+9Vd+iz9++2Vuh1NUFZwcmprFs888\nwxNnL/ONP/wqnm4Rtw84c+4MiqJhajoiBn884YPve4wv/fTP8b//9/8jiwvrqGi0ltfY6t/GqjjM\n0pzbd+/y1GPLWFpE2RLMigzNsXjx+i1+zijhlVyKLOPEaYuNjTPs7R0g0pTLZ07zypt30YVGhkK7\n02WY77Gy0qLSWGDRMfjRT34Y/7DLc889w0LdZe/hu1TLHqVmnTSHtaVFVNOmc9Tn6uXLjCYz/uxP\nX+PR/XtUFyucPrVJ2bGJfJ9+54BGtcatt9/AnwaMJmNs2+TM+XPc6x4QRjMWljyuPn4eyyuRKzpB\nEJDEU1RDJcoTRDwjmgY0m81jYVMcBpRKJer1Oo/2D6nUarQHIxq6w9Fsgma4HGzvIMwSY9/H8iro\nho6dCWxdFlSh5IhCoWqpNJWXuZb+MEluyKlX1/HKFZK8wHFK1BoL9HtHJFGEamqohUBV/npVragq\ngrmITWikSSo56KKQfnEBKjLNzLQteR+nQNVU4mBEZ+c6rZPvY2Q/QSn6U7SikBnIGaiqgZdsoVpX\nj5GrZXHAavoyah6j6DqagmwUhDguFu8p5BUZiXZMRyuKQvqZVYUCwUGnTbNRIvYn2Ib0i5drdVZX\nPYJZiNDAMiwJmNE0hsMBCwtlym6ZMJgRRj7VqocwbFQUXFu+4vb2DyhXK8RxSsmryUk4lkp4fb4R\nqDbqDAZDiW41Jensb6783xOqqYpJkUMUJnieh2OXAZnWNZ3OOHXqhMShahonT56cq8h93HJZZpGb\nuoyyDWbouoprVmk1KghFIY0jPNsjCnxM18QfjwgDn3pjgelojG7pCKFLwEqphBCCer1OrVJhb2cX\nXVGpNRv40xDVUFlaWkYIwcWLF4+hOcOhpKItLDRIotncoz2kWrYZjyd4jsTZ1ubWOdu2jif3TqeD\nrhvouvSg257HcmuFKIrodvtMZgGNhSZOpUSaxpiGiqnptFotLMdjzavQPjykQJ56QGVv74By2aNc\nLZGkgTw15gm6IZjNZlTKDQYj6bHPc8lSP9ifYOoGSpEz830ev3SGfr/PeNRB0WIMU1AqWxzs7TA5\n7FF2bOzFJsFkwp1bt2hWK6RhTJEWnFyugaVy/vwa7f0+zcYyr19/GzVRObexwUef+zT/15e/Tnka\n0iw7XDx/it29+ywsLfLqq2/xhS98hn/2z3+Ta9euce2111lZWaPdbnP58UvcunWL3d0dNjZWOLu5\nLp8zVf3rn/vv8/MDUcC7+w8Jk5jxZEjoj7BcBSEURC4whYKaB6hFjsh1NK9GXmT44y65Krv52dTH\nspz/l7v3jLE0Tc/zri/nk0PFrq6OE3pmetIuN3GlDcyUSItJFJxg2IYtA7YBw7QgGKQMCwZsA5Qg\nQ4AImIZpw/pjkJKYlty8s+RyZ2d6Z3q6e3o6VeoKJ8cvJ/94T5f4f/4sXECjGoWqU9/BOfU97/M8\n933d5LnoSAyjiW5byJKKXMgsZwFxEbG1s0WalBx/+BDKjIrjUJYJmqygGjpBEDCaTMikFQivlCkT\nMQb9/g/e5f779yiKQEQG2vb5/s5xHNGBWzau666EIqKAW4ZJmqa8fPM1Wu2KUN5KIGkFZVZimway\nrIprlUR3n8ZLdFVFLkpho1M0ykLGMh0adY9Ou86g3yPTdVTH5N/86z/m8P4DEVkXxRR5yuXLV/mv\n/9Xv8off+ya5CoZmkcQpuaJwmiW89cEHPHh0QJAnRH7KUTThmnRF5DEPAxquzWA24+d/+meYjk74\n0hc+x+71y7Q6TdrrLe7fKihLiVySGY5HRFHET3zhMyz/5G2OxhGlrLKMEv7F7/1Lfv1Xfo5Fr896\nq4aiaCRhRKtVo1V1keISTRM7/D//sz/hf/zv/z6T2ZjxdM7Sn3Jta4ff/p/+AUGe8OqLN+j3zyAt\nCdScapoRZTnT8SlFDt/62rf5q7d/SFhAx3N54+bLeI7NJ1+5wfHTfQaDU0xDIVdFsVN1hdlyhqYp\n6IaKqnn89E//FJZTw/cXJHEohEtRiOu6KFJJkgQ0mnWSNMZ1XeIkYrFY8PT4RHRgR8cUObz6xmfI\nS40Hj5/g1prkJeiyg2tp6LZDkuYY5GjILPIY16mQFTllKaEVGU2px4AtUFwWizPsio1q6aglDAYD\n4jhG00TWcUGOrqqkhSjS0l/L/k6TFErQNR1JkUURL0UBlSWFoizJV7GvJaVQ5j/6Pt0LLzMu16g5\na5CPzgtukqVQ5LSK+wzkF2kX91hTHpMh0r7kAsq0OA/zUBRhwdI07byYJ0mCYYi987PI2VICy7FZ\nLHoEQUCj1iBdrQumR0fUahWKXDr/mSxPqVY9FMcgixOm0QjPMdENkIoUf+FjaKaAKiHhVKo0a032\nnxxw7frznPTOmC5m53+nJyen+L5/jjydzYRH+1ngRByL19t1HbJUENQajQZBEOA4DkG4ZH19nVqt\ncq4utixrdbAX04d6vUYcRVAW6LpBoigowHw+p1arEEYJmqqSJhHVapUSGWsl6k0CEakpnCxgmiaO\n4whm+4rlHoYhly5dIi8LFE3D1HWiKMD3BZ3t2eeyzFlf77JcLnBdhygOqNfrLJdLZE1hGfrnojnD\nMKhUqjiOw3K5RFV1ptM5lmXgeS7j8Yg4trFtl+3tTWRZ4rTfp9tqkSaiO346nbC5ucnd+w+pN1v4\nfki5yIjCjEGvT6PV5PHjPZIsZmN9i2q1yru3fnAesDKd+PTOBnz5y19mfaOL7y9J40RMOgydJ0+e\n4C/nAiRTr/H9d99h99IOhqGzub6BnqVE0zm942PSNObRowdUXn6Far3GYNTHrnpMo5h37j7g4vYV\nHh6PeP+jU5rNOlaZcbVa5eJWndc7L7G9voapFfzs3/os08mcF164jqLopHGGYej84t/5RYb9IZ94\n41WSJKJacfjMpz/J89evEvsLFFk+f15bW1sfu3b+SBTw46f30R0L2zGR0UmylDCI0RQTs8iQixRT\nKpFkjTAKGY+n/OTn3uTWh++zvzdC1hVyKacgJZM1Sl1ilPnoeU6RKsgKaIaGoihYromlG2SlRCZD\nnopDwHqrQaVZJQxD6lUTy/JQZRVNlqlXPDGaSwtcV4AuJEnsYRRZPK5hmRiKej7O03Udy3GwTRPP\n81CkiCjMidMcRRM5ymUBiSyTJSn6itMcx4HAwZQ5RZ6fjxk1TacoUrEDUg5QJBmpKMmygrmlcJKG\nhGVJYqg4Vp3B8TFvP/4QV1NJ0pw3btzkaG+fwWJMJJXM4gWdZoOsUAkp+LX/5N8nXe4hFT45UJQh\naVzw6KMnvPz6da688RLjcIQsJ7SbHp4nbBqSWnDa7zGdznn95Zt841v3GEwTciRK3eT+/QdES5+X\nnrvKcDphMJ7S3Vqjs9bk5isvMzibEkY5jWaF+XTGyekpT0/PyLOS4eAQLTUw9AJsh++//x73fngP\nOcloXFjDUGUOz3poOswHM2y9zlr3Ipdu7GCVMsd7jykpWKy1KUmRZLh95zbj8YxK3ePChR2uPncF\nxxNYS0lSGPSnWHZGngfoMiiKJfCTgGlYlLKEVOY0m/XzSMPpbMYi8CklKPOCRq2NP08Jo5BarYWk\nacwjg0ViYikSQRQQpRJGqZOnoJsuJDmZUhClEVGe41lHDIotTvo+3/7Df4lZ8YjjEEtRsVSdfFXE\nFFmjzAsk7RmHH/JCvG9KSULTFKS8pCCHMqdEEtoOQFZE16usPM1lIZLs4uWS04MP2Ni9yVh9gXb+\nLcpSXnXPYsdeSe9SVT9CLkvSAnJKCllCWe28VVVMj4pCWY2OBb9dUQQX4Zli+Nl4PY5DFFX400eT\nMZ1Wk8l4TK1WQ1FV4iggLzI8yyNOIi5vXKAoheJ6PptRdT3BufYsTk+OABnXdvGDiMlyThSn3PHv\nYWsOurGPV60RBgnzpQjb2d7ZIQxDzs7O2N29LKxDKxBLUYhRvsj2VlBVhdOzObohBKOKKqHpIs3Q\nNE1CP0BSZGzbJkliFos59Xod27JY+nMMQ3AGpKIkzXLRzQcxtVoDypz5fI6slMgqzJczNFXcw2xT\nJ4giDMskSRJGoxGKouFWxESls9YlSmJUXUc3DSpVj+AsoNXtMOoPaDTq5HmOJIkDSRrGpGFEEEfU\nqw0oJFrVBrPFHMtyWC4DdF0/V6gbhnHOnU/zksFgSKVSQZF08rRgGftYhkwQLIhiG4oERYZKpYIf\np6i2S5wm+GFEu9lgPp3R6nR49OgRk8kYVdd58viINH1Crd5ga2uLNE25e+cjfuzNT6GqKrPZDNu2\nmE6nHBzuocoSfhigGjZGWrKxdZH2+hadTovldI6GRpCkdNc2eP+9W0iyzM71FwhKmcVoSqPeZWP9\nAt+/cx+34WKvbTI4GjEtIZ6WPLr1FpKt8uL1q7z9g+/SqbyJU2kz7w1p1ut87hc+ge8vuXPnPUzZ\nIpj6OJZFEISMxyNeeuklarUap6c9iiylvlqZ6Lr+/x8Rm6EsiIIJRaKT+DlpoaEW0LRVsuGU6egp\noaGA3uD+ySmxJPOp/+E3OJufcHR8jFxalIVMniXkZU6Ux6JrlWShYC/A0jwoLB7uHSApKlKhoKsq\n08UCxzZYW2+KMV/VxnNtFNUkXMYYukRJSklGrV5B0wzcirfCJDqCSW4ZyLKEIpUYmsnW5vb56Twr\nhSK9TBOyMieXC2QySFNK2RI0KsPCn05Z+AskSUVB/GEbiiq6K10lLwviqMCyHCpVg/XtKopaYTDt\n85AM9/kb2JQMJJ/cddl/uI/tOuiSw9988Q1OZz6/8c//BX/x7a/zB//H7xCmCQ/39kkUFc3R+Hu/\n9qv88e//Ls21NfqjoVDoSjCY9Gk2PgXpiLVKAz/P6DQsZBNKqUAqE6aLJRe2L1MaA9544wYP/uBr\nJKWBoeoEs5B3/+I2+msZjbUKjWqFspQ4Puix1enwH/17v8ZXrSHoAAAgAElEQVSTJwd88rMv8+jR\nPsNljOPUqbkOnWodf7kES6Xd6vL+Bw+wa3W67QbLcMmHe48IljGv3nyDF67WmfsL0jxjMjqjcBRM\nUyYKZvT6M/w4otndxKpWuNyuCyqWZdJurTOfBczGgjtv2w5ZGuOaNmWaoJYqhm6RlwXTyQJF06nX\nqkRJhFQWNOsOcbLgs1c+SSEr9MZLFiOfs9EUTXdQJJvZUqLQxLg5zA3UIgFc4tU4OYtBkWLUQkRa\nomoY6QBJydHMOn/jJ36CxWzGuN9j/9FHZIoMeSGEm6EvDn7RKvubElXTyAuRMpaluaCmypIo3rIQ\nRcKKkV6UyPJK/KbLkOcUZUnv4BbrOy8xlTZwU4OqWZLEKboqkUsKrGxsyqqrXuEHKVfjwbJUQVbJ\nCiBNiZIE29TJ8wzDMMQeXFJI04Q0TdENhWUY4ng1Do7P6DSa1GoVTk6egqSwvbVFpWqKZLW0oDfs\nYWgKZ6dP8ecBYcWnLCJhJ1uEzP0lrEGcl5iWQ0lMq9HFkFX8xRLbFj7rl156icd7BwyHUzrdLq+/\neYEyz4gicdAwNIUkSQgCnygKkSSZ9Y0OnW6d8XiEYcq4do1sHmOtsKsAhmEQRRFxHNNsNNAVlWi5\nQENmOhqTJAnr6+vEWcrEX6DJMkN/ganplLpBmSfkaYmrG0wmE3Z2LzIYjUGWODnro+oiRc1zHFrt\nLvP5nCj3mc7n58CcLMswNR0FCc9xSbIUWVPRcx1VkdE0mdl0iuM4kKUYqsJkOqTZ6jAcDkmSFNe1\nmU6FYLDdblOv1zF1gzhNKFWF5XSGv1iSJDGGrnJ29pTtnTWOn0xFwEqhcOnydfrDEeubW2RZxsHe\nIUmYsFzMmM3m3Lp1i9dee41ma42TkzMcp0oSpTx5dEyjWWdzc5OzwelK06Fy//4ASYLt7W1arRaO\nY7G/f0SnvcbW1hb37n5AlkpUai0Ojg9J/YjupsWNT3+aw6MzqpLO+nqXw5N9br70GlGUcSlK2bm0\nw927d1H1FNtI+PIXP8Wvd3+ejQvrzP0p156/QLPe4s7tD9B0g42NdaRCpuo20SSH1197k8lkwqOj\nx7z04g2Wvji4KZRUbAtJsvCX8/PQnI2NjY9dO5Xf+q3f+tgP8nE/fvN//t3fCqUqidJgbecFrr/2\nSZ577ce49sqb9KOMWZmzefUKk7jg6XCIW7P51X/nS5ycPOXJ3hFZhggIKRI0TcJxXfYe9cUIXjfx\nvIow2mcJeZGzWC7Q9BJNhvW1NmvdDpoq3tDVisjZLUuJaq2KZRnYpggE0HUDiYwwWCJRosgShqHj\nWjamblDxKuJECsRRRFnkFEUuREa5jCbJlFmBgYRRlpTIaLrM6ck++/v7zNKSIJLIswJZk6HMqbo2\nb775OopaougysuYgSRbNRptOs4tKyePeU97/6DGHvTNOxkP2D0/xlxGZJhGXMv/gN3+TP/rW19m4\nfgVJk+mfnjAc9OhWqwShzz/+R/+QOx/8FZPBEU9Pexwdz7FtwV1vNz3+7i//Ik/371HEMW7LJUpT\n3vrOX5GmObbtMB8ueO3FF7i86ZFnEAQxvdEQVBVJ03h69pSbb7zMyd4TBoMBjudy9+49XrzxAkmQ\nsN5dJ1UkPrr/GDmVcByDdrdNvVPDqticnY1559Z7vP/BPZaLOZWqhW3q1Bt1nrt+AUUuiUKffv+E\n7//VOwwGAbN5ADJcvXady5evYNkO1XqTTrfLha0L7F66jGXZTCYzZFnFcV2yNKHi2khlhlSCIkuC\ntTwZrQq+gWWYTKYnxFmGpGq0WhvUqmuc9udMJjEHhyeEy4T+eISqKSSKQaJ6SBIYakFeyCCplKso\nz0nvEMutUeQyapmimRqqKvaG06xCJlfY3V6jWjUI4lCALFSJMhM+41IuyYucfMUZZ7VnlgBVUUQU\npiyJHXZZCnGlJAluepavIm0Re3FFXvHUC8IoxHFqOLUuhaSjBY9RFRVZkYji5BwHKq8OIc/AJM86\nNkmS0HT9XNgJoGo6eVFSIiHJClleCk+7oqJICnlRkuU5wcJHkWXWOh2G/REl4C9CJGTmiyVxkDGd\n+iyXEVlaMp5OabXbzOZjKpUqtUaTKInorm3iVjx0Vce2XKrVKpoiUfGqZHmGYRokcUSjUccPAqaT\nMRXPIwwD5ospSCWtZgNJEhO1SqWyOgBpqKpybuMqikJkrBcl/cEAZBnTthiOh6RZRqXiUpQFURKL\n3GxFIU4zgjDCtBzSosD3I/JSHJ5KCbIkY7acC00NpVhPyApplqGoGt217iq2WKLXPyNYLkVoyGLK\neDzCtAwmkzGjwZBWq0lR5KRZimXbGKvXydA1QVVcvZbT2Yw0yzh6ekyz2UTTRA66osh4nksYBERh\nyGK5EMTJIsfQhJPCNA1q9TphHKMoOoqsMZ0usB2PNMvpdLu8e+tddFWl1Wryg7e/zysvv4QkwfPP\nP0cUheiWg27qlKXE2sY6SZpwenbGoyePqFSrFCXIighZqTcabG5dYOkv+d73/4qdi7t4lSqT2ZSn\nTw9ZWxeCO01XqXhV1jfWQVHpdjfZ3NpGs3S2d7ZYLJbYrkut0US3bbKiRFY0rl1/gRdv3KDRqrH/\ndB9k+OpXv06r2aFSrfHeD9+j2WgzmcxoNtvUalWiKACpZBksSNKYjY0N8iQmSSOePj1iPp9Tb9Rp\nNhrnIJyNa5/8Rx+ndv5IdOBf/OLnKQ2TJMsY9c7ICfnw8RlpAoXl0HnuVRJibl55mUs3X+PD928R\nTWfUaw6WoZMmBVmaQlFgKCZFnPN3f+mXuHv3Q+7fv49KjkyAqirUXJ2dzatYpkyr2kYuZYpcnDQd\n12YyGeF6VdIcdNtEVxUoM2zdwvM81tc2UDWFIs1AylAUiUJawTJIKcoMqcwogbQoyHOVNCnQDJ0s\nTVE1k6SUMQ2PSDKRXANNMXCcCqovkZYxRQmKrJCmGaquEEQJex/t84MP7jGYRCwDnzdevka/d8Av\n/OLP8Jdv/4DvBe8z6c8wUjBkiOSSl9evc+P1l/ngne/yi595haff+kN++stf4vP/2X9Ae7PL/OSQ\ntY02veERlc4ux/sJt+8+QtEgCAJqdY+Dx484fPghap6jGSp33nmf7YvX+LE3XuMvv/8esqxgVWr8\n33/0R6zv/hLNVodf/ls/hWkp3Hn0FN302Gy1uX3rFl/+zI/hRyH9s1Pa7Taj/ojFbMF0OmUWL+i2\n19Fkk2++9U0ytaTUFApZYqdxldde/wRXr8x47ZVdguWSRw/uU7NtLFNFMmR0RWa9vYOhl3zv1j7L\nWGG41+Ptd+7RrlVoNlwqVYvOepN6rc3J+3eo1+usrW1wcHRI1XORkYjigmtXL1N1PY6OjtFMka41\nHI8wS1MkXHUukSQy/dGYh3sfQqmQ5AVZWjAaJ2xt7tCtbpDlJX7uIgHXLzYY9B8TZzWKUnTAUlmw\n9/471FobZKpGgUKUF8iAEoc4HBIqm0yWJbZSUmvU2dzZ4YMf3sIzLZJQZEIrsiLiSPOcvMwhK5Bl\niYIcWVNW++tSwGBW4jLxL0eSFWQh+KDIc4FkXUEsDu9/l/b2iyzVS8SjbyClPVRNwl+G52PlPBf7\n92eBHM9gIYomVktlWZ67NMpVB5Um+WpHrgjbVpZRsQx03WAehDTXLhBEGXfvPqHbbhL5S4JgSRgt\n6TTbaJqOprvYriPG1hUHq+qxYerUGjUxxk7BtGuYps5SCYiiCPKCTqclshVKE7koieIYfzljY61F\nWUoEwVJMBBSVqutxcnKKrgt9jGEYaJpGnsnIisFgKLQIy+WSIofxeMyFCxdYX7tAEPnkhUSz2SJK\nUoFeVaHZ8kjTFK/eZLkIWAYRjl2l4imouvJvo0SVGMdzz4NJ8lwo4g3LRJUUHj14SLvdJggCvIqD\npgnhr6Fq1Dc2sW0bBQmjIcJl5vM5kgL9/plY6zku9goZXKuL6ZCmGRzsPeHChS2i0MewTDzXJggC\nNta7DM56+HmGoeqcnQ3I0oJms02eCw6+JKtMJj5ZprJYjNE0hdncxzAdkihie3MLKc+ZT4a8+MJ1\nnh4fIssyV69e5vkXrjJdRDx+vMf6rtgNJ7mL5erYnkalUqN3NsCyK3RaHb7/g7eJk4Kt7TVeufkq\nkiJzcnaMbdu0Oh0M22I86DMYDnErdR4d9Oh2u+Slwv0He8IhIJdohsUszlBU0MuCWrPF5asv4Psh\nbtXGD5a82n6FPC/YuXCZooDT41N+/e/9h7z11lvCApmk6LpKmsbs7e1xYWeLqtehzGOmszG+v+TS\npUtUKoJbcHrWx/d9Hj9+zOs/+/Fq549EAf8/f+efg6ywe/kyr774POOjffxFjKpYSFJJSYFqKZRx\nRB4HeI5LpValKMVNI89E2lcZF0RRRFPW+OrXvoJrOXzyzVehKFBUobQtyxK5zFFKheV8TtWuYKgG\ntm5Rdys0Kh66YeC6FSqNOoYpbkS6pKDKGnEpUsYoSxaLGVmek69O17qloesixECSZUzNoFLtYpo2\nkiFGXpJuEmcplqaTYNKt1xg8uM14NKdIc0wFoiIjTzI0WSZB5c/+/BscnU0IspJczVF0GcurMJ5N\n+X//1R+g+BG/87/+L/zTf/K/cfvWbZo1l0q3xX/+3/wXzOZjJsNT1DTlv/zv/lNmsxl3bt9BCXUa\nrsrx8UN2r2yjuybpso2UF9RqJsEiJkkipKzgT7/yNW48fxHLVal4DdrNFltbG0TfvoVjihjC3nCK\n4lQZn/Z55cWXBGs4yhlNlmzUG1hSwcHhI6aLOW7Fw1t5U4+Pn4rpBgmT4TFnk5iggG57i8lsjm1Z\nJFLG/sFjNloVpmfHVKse7brInI79GKmEReKzd/AYDBvDAsOUuHjhOom/ZK1Rp1YxUYyC9lqLLAXT\nvESapkRRwFq3SVmWOJbYd6MpRFlOvd0mKXPMag10A9/3GczmFP2U+SKm1qiTZBIHh/t4noepW6xv\nbTFZhuA4TOc+liu6tGqjiia1OXz3GKcuYgTzPCNPStI4wFCryLqG4QiohSJJrDFiWJQsQolu1yVx\nQu6dvI8ia8RpurIK6aR5SlmAtFKiF2VJkQvLt6ZI5+zzoihRJNEtK4p8rtd49nNZlqKsqG15XpCE\nc/LFIWrlIurG36QZfhfD0shWNslnYk1nRSF7ljv/LHte/muHhSgSqMs4TlYdunL+/YUmQoziJBdK\n4yRlPJ0wSyOqnkG70+TkLKXdaUFeUK0J/3a9WWFv/zEV10OTYBmFBIHO0+NjDMNgNp0TWwaTlYJ5\nsVzQ7TSYz+ec9YcoZYGi6rjVCsvlkjhJSdOUTqtNkuUUBcRxusqc1jF0EXJSq4oRc63aIkkSPLdO\np9Ph8PCIarVKkRZImUyZFMzH4ncnoRDuhWEsqGJhhCoLzj5FQl7IWIZLXhTYho6fJiSxiCRWFfH6\nVBoVklTY2qo1jzJP8RxLcLrz4txCVq0K9bjnuPQGvfMc9MVyiWYaUMrkeUmaiudblmInPh6PMTWR\nClev1yn8gDRN0TSNw7391WtcYBgaSRKi60JRr2o61ZoIH6lWq/iRz/u332V7e5tLly4RRREPHjxg\nc3MTr+IwGESsra2dH0w2NlaBLqWEqStoCiwWC9LQJ44idi/uEAc+UrvO7sWLfOc732V7fZ0rl3d5\nsv+YyWREt9vl4sWLjAbCGnq4t8/p8Ql7e3t8+rOf5cLuLgBpUvLKK68SxzG+7xNECZatoclgmgaW\nZbFYTAHQVY9ZLISURVEQBgn+3EdVFDqdBp/4xBvYto1hGNy7d4/Lly+zu7uLbenCPeT7SBI0m03K\nEmazOYeHh0wmE65evcrFixc/du38kSjgmulRFBn7D+/TcjTq2+uUxCxnC4wVe3Y6WjAZDKFMOTs9\nppQLlss5y6WPLHsrcYaEpuhEQcjO9roI+DAVLNOiVqvSatRwbI9ms4XtVqh7NRrV2sreUqJqMsHK\n2hGGIaPphPHIJ4oioigiWAYsspDFfIksy2yt71Kr1el017l0dZNSVcWBYuXfliSFyTjgbCi4yVEa\nEwFRFJCEPmkhU0YL5HlPnPIHA7JIQspBMWQkRWHhBxz1hoSJgqTqlNmYrfUOsb8kiiJ6wxGfvXkD\nzdb5b//hbxDOp7imQa3RwFlf463vfI2Lz+1g+hX2773L7/3e79HpbrL+kz/DlSu76FOd6XRM3ItR\nSNne7PLgrEcUlSiWQuynjOdLbK+FYeu4hujYqlWLigdylqDLBkWScXywj6t5jPojpKwgmA2xFI2D\nJx8h5QlXn7vC8qP7XLy4hSSJDGTD0ul0m+SpSqu7RbE3IJRVISKUTGaTKYk8g0LHc+qUecHDh4/P\nLUhetUqeppyeHnN8fIxVayKVMOj3kQuNnfUuz127hFcxGc+Gq4JSUG9UzyNfDcOg0WisbmYl82VM\no+GArFFGKYVkEKcapeRx4eIu7797B9B5uHfIhZ0dthWdIs1IooQMBbPawM996p5GJMK4ebL3gJqe\n05BCpv0DZEViPOgxTbJzEdlkMsXvzciLFK1Q0VWJorKP7O1SyC62tWBzfZP5coEsl1zY2mD/yR4g\noyhQlsVf666Lc5/yM8SnLEvn++6yeMZIl1agFnlVyCVhSVMEdrWqTPDZITSuYBv7KOUETQwQzgM9\nRESosPc8+1qystg9g7hkWUYSRaIjl1VKQC4hi4VnW3cM1FUAhyrJVL0Ks+ECRZGwLJGApakmcS5Q\nxoapc3J8hK7JJHGAUqjIUkmepzSbTVRV4+jomI2NNS5cuMBisThnrw/6I+EZTsU1appGUUpEcczu\n7kUUReH4+Oyc2y7LMq7rCjGqorBczsnzFNuuY1li1312dkKjUUeWZQEScUzqtcrqMAaW63B6ekq1\nWiVZBaAAwgMuyZQrdX8aR8hFhq4q5KnIe5dlGUPXmS8WSJR4roOHOEzMZ1PyrGBjY2P1mELz47oV\n4jBA1w3G4wnj4YiFv8StVsiTlFajyWI2I8syPLdKlmU8fvKYmzdvUq/XuH//Hp3OGlmcMDjrsb6+\nzp0799je3mZ//wBNk7l58yaHB09RNQlVlbh58xVkWeH4+BCK1wCJBx89otPp0Go38DwXypzd3V2m\n0ynNZpMwiPn2t7+N53nC5mpZjEc9gXVNYq5euUQQhWxc3GI2W1CveWxudHj08AmPHt8DWebqtSu4\nrst6d43JaLyi5XlsbGwShhFbW1tMJhMu7lxiNBrROz3DcRxCP0A3TNIoJiHj5OQphmHgBwsMQ0OR\nIc8SQl9Y7Sq2ia1rIrfen1OUCYpqoaoyUIgDQRCgtJucnJ3x3HPXmeztY5rioPvWW29h2zaLxZJm\ns4VhGB+7dv5IFPDG+iaz4QmmbuEvpsi+RxwmFHHAeDAnCgtsWycMT5lNxxSpSFqqVCrkuRDhKIoM\npXwO9f/ff/ufnY/zNE0lyxKSJCOKE0ajCWGQsnf0lFs//CFZljEY9lhba3PSO2PUH6CpKkVZIusi\nms4wLOr1Oq2tbbav1Gi3utRqDaIgZjgc89F332a5DJgtF0yWc2Z+QJTE5ElJlqRiVF9myLqBriq0\nqw6y5WBKMTVlgWWJvGHNsCiTjLwQjOY0T1kmGW7FIU1CwvECR+rgT4eUaUnsJ5i1Gk8OD9BVEw2Z\new8e8su/8ivsHz3i6d5H6Nub1A2FOAq4+uJ1PLdFocFe74jhckk4GvPy9avMlz28mkuj6TCbByQr\nT3ul2uTOnfu8/uZrhEHM0n9KveLh2jJKUBAmPgs/5eJai+ko5GDvEFWX0FQJw1AYFRGdbofHh/ts\nbIqIx7KUaDRaAquYhHi1JmFecnR8RrAMiRY+lqpw8uQBl1/YwjZatDsN+v0+iuViKSpxFJEVOWGc\nUyo6z924yaODY3pnAzRDxTR1VEMGNSUrZVRdw3OrKLLovJIkwTat1S5XJ8szeoMxlUaLd354j9CP\n2N7e4fDohELSkBWDvf0Rk/GUarVOvd0SGe6KxLA/IQkT0smSUvOQ8am1RTDIYj6mpiZ4lsO1yx2i\nZcZgNuBLX/w7LH73/yKMIjzDgbxESQocxxXFtEhpqgMm7DJdSty4ehnLrfHqj30SVcn5zte+Cojd\ntSxBkuSUpei2JUkWUYhlcV5Un32Uq2wswVcXY+6iEORBEEU3jHwa7Q6thkMRDgjlDqf5FdaL71Hk\nYif8DNKSRNH5DjzPc0Fak+XzjlBcjwSyjKZqq4JfggSFIMAKIlshbuDhYo5mmVS9Cnfv3sVxbRzH\nIssSGo0aqqpyeLjH1kabKBaK6Xa1jiLJ9CYT2mtr7O8dcunKNTzPwTAMCmQqUcR84dPtdnEqVdIo\npixzckqq9RrNVn2VR52SZYLtUK9XRWSoY6NKMmkmEQQBpqUwW/QF6CSPkOSMZssliWPiQMLUJRzH\nYjwbIysqUbxANySyPMTxHNI0QlNUgb5NYjxP6FEUCUxTR6IgzxSRJidJLOchQeDjeC7zyRhFUTB1\nnVhVaKyvc3x8zPr6OsPRmDQVB4TRaMRkMqPRaCBJCq5bIU1ybNNGUcREMAxibt26hedVuXrlOs16\ngydPHjObTsmzjGZTpNOlacrOzjaj0YRKxSNJIo6OjkjTDK9i41UssjRnf/+QPE9pNBooss721i71\nepXRuE+ahciUjMfR6jBTp1arYVkWpmkSJwsGwykbGxvi8bKMStVmvhhjmG30SObho7tc2NkExEpJ\n0TUkWcbzKuwfHtBdX8NxHOIgJlRibr7ympiu2cJJNJmOsG2bOAswbBVdU1FU7XwilecpkpzjujZx\nIpLoqhUbz6sSRQmLuc/jx49IVpqTc1SwVDCeDDk6OsIPxGHqyZM9oYlSFPKs5M03PomxSqqbzWZU\nvNrHrp0/EgX8pZs32f9QwiljHNPg8d4ZwWxBMp1RrxtUvCZPnuwLJW1ZoikmeaEQBAG6plOikOdC\nkh9HKa5b4U//6I+YTqdM5jP8UHghF/6SJCspCwWpAEUS9o9KxcW2TXTPYHt3h62dHZq1uij+tsfa\n1jaqqjEajTjuBZz2Trlz/x3Ozo5ZLhbYhsmg16fT6eDWq2QymJ5Ot95CU1XKLMf3Q5azKd3OBt1m\nk2/9+VeottaItJRWSyVLYzTTYjSMUSQFyCmKDIkMTTdJ8iXDwQGX1y6wUaszW8wIFwGSpPH2rVv8\n1E/+bU4PegwHA9YubHD5pVd4751v88KlXWqug2kpqJLHq4ZHWegEeYIUZoymc5xC4uTJAR88epes\nLNFNFcPSSeKMrChYBhFvvnyDTqvNIoyxbB2r3uDnf/YnsWKNLFA57R+RZUvanRaGUeXehx9w49o1\noiRhd3cXRVP54z/+Q9Y6Am3pOC6mqbO2uUZRZowXEV/71l9w96OnaIpEu1Hlxssv8NzOOpan8MZr\nrzCejTG9Cq5bZTYcM50tqTSrSIqCZlZxKg7ddRW7skNeZmxvb7G13mAZjFGNKppmMF/4bLRrzIMY\nSSoZjSbixtcfcdLrI2kGuRTQqK8TaD69szGe08aPU856Y/JSYhnGPNp/H1VX8RqCqKXKmuggDIfc\nqGLZm+QlhNMed979Hpd+6lP88Htv0e1sMg9lPjg84M7+gGrNIQxDvCpsbWyRhS66Y4KqEkZLwrjH\nBBgvSvaOj8hzlafHT/nGV/+UMlii6wKyUawiP0EAXCiFT78oShRVosgLgVItn43YC+RVly2+Jrzb\neVGArKw6zSXLxRJHDgilFgv5Is3iDoYidu/nI/CiOB+TS5JEsbqGLMuQFBFXapomQRCu4DcysqQK\nmIWmIUkxaS4KVRrFkK9IYHHM5ua2sDzlS/JCYzgeomsKhiZhGOBVqiwXAuq0DBNUVSXLc+IsFyJR\nQ2e2EJnZzWaTPA6xbVv4okuI0gQZUaAKoFgx2m1Hx7RUNF1G1iSKImWZJATBHMPQ0FY3/ihaoukK\nhmnR6x1SrVYxLQXdgCwPKEnQDQvD1EFK8aoVypLz3b+nCUfLZDihvdbG1HShCZmOMQwNw9CYTqdQ\nlLiOQ57ljCdDKGUs02Q4HKKq6vnuPstSqtUq77//Hq1WiyTOuP3+HW68+CKL5ZI8z9i5sIvnujx+\n8BH1eh3Lcnj++efpn/VW+dnOORLaMDTGowFJGrG+tikIaM02mqZx/8OHdDprFIXoPo8Oj9F1E01V\nCQIf0zAoS4n5fI7nOcShz2Q2JssKbt++zec+93lu376N67qYpsne3hM2NzfRde3cQz+ZjKlWKxwd\nHXF6eoqmiQat021jmLYgI+oag/HoHPwTxgmL5UKggeMEtxBv8tu3b9Nq14FcMDosa3V909XvEmCn\n689d5uT0CFWVsUyLKIrx/QWyrJ8H17CaoliWyaNHD7Fti7t3P+DFF1+kWmnhui7DUf/8eWSr6d4z\nnK3jOIzHYy5+zNr5I1HA5cmcrarBG6+/yVe+8U2WgxkNx+FX/+Nf4+d+5udAVvj9f/OH/D+///sM\nx76IyVwuWEwjcZNQc7IiFYlKioGiGvzBv/4TbNulWvWo1SpsbzWxbBPbcmg0WqgKVOtrGKZGw7Ww\nLJksi4XCN4coLtCsNsso5sneCY8eHfLB3UdkbkkaxXgVh9bOBi+tb3D3/dtE/RLNVXjh9etMQx+r\n5lKr17FlDRUZSTeQ84yWU+Gtr3+NnBm63ITc4Gl/QSq5VGoqYbhkMRvhajp6qZCVKovhCY6c8o//\nq79Premyt3+Pr3zth6RqTJBJnA4C5kHAj3/hU/RODtjd3eHJve9RcxUq1jrz2YzJeM7ZdMDx8TGT\nyRi5KCHNqXoVXnjuGvd7p8wLF8sw0NJDtEwm9HM0SWLQO2Zr96fYO3xE5Oc0mi5np0/ZNl2q3Toy\nMp/+1BXee/cetdqI1998gzc//QnyPOf+o9tcuWKhlQWvvfYalUqFpR9y2hty+/4+nldF1wxOZiNU\nvYohD6g6Fl/83Oe4+dJ1tjZb7D3d5/a9+7RaTQGQMOvzGJUAACAASURBVF1m0oK17YsoqoQsw9rW\nBou5T7XWpd8bU/Uq1FsOjWaNJLEoCxFTKUsZQ3+JLps0WnWQZc7OhvT7U7LCwNFqHB/NidOIMAkJ\nw5A4OMSzXQanfc7OzvjEmy+zUW/iNisomsF0ERGVGYotUyQecSJGxGXQ5/F7f8knXrmK56p86nNf\ngFJhMJxz+caLfPTwMT94+xbb10Row2zpoykF8/mMMs8p85w4naDVB6Rqm+WsoGDObDZhbW2N6XhM\nFvgokkRRZKgqpKlQoT9bC+V5hpxJqy4gR5YlJElG1VSesaKzIkGSRPetlAp5UqArBqEfMBqN6DRc\nbGVEILWZSFfppO8iw8rn/G/93OoqTjdNUxFqYtuUpWCNL/zgXO2c5yl5IUhlaSISsEzdoJBU8ixC\nVwSwJUan2uqyttYgDMNzP/JsFuB5DnmukSYKw7MevXxMp9nF9nSkLOHyzhqGobIcj9EsnTgNSVMf\nrRBrk17/CE2WVkEvCsupLwqXpnE66JNlCe12G10u8cdDkiRjsfDx3BpFHuMXBa7rYlsWs/EE0zTx\nLJMyyciiiDQMMS0dU9XJ4hTTsTFMB8dxRYpipYK/XAomue1gWjJlnjINlrDyaauqSlGArpuMRiPS\nXKwtykzGrVTo93s82TvgL7/3Nl/6iZ9gf+8IVdeYTI7Y2toRDcXzNe7cuYOmm2xu1pkvxuiGynDY\n5+6D+5imzgsvvEB/MiAlI5otkaWU7a02jt2g3xuxe+E6G+tb5EVKuDhEkxQMVeHihXUGoyFexeTh\nwyPSvOS557Zo1Kqc9Qfs7R2QjsZ4nketUmU0XiCrOkmUMh7G/NmffoeXX3qe3vEhedjEVHT8yYyn\nccpxr0e7u02el2ytd+gPZxiqQ7UiVl/L+QJNNbh35w7VapULFy7Q7/dRkeidnlCt1gmzkP6oj2aZ\nlKSc9Y7pdCpkcUQQxCBXKbKC8WhIVIBX9VB1nSDJiTOFsjQJ/QTLdKl6TQ4O92i32xwcHRBFAvD1\nzg9usb29zXSy4POf/wKapnF8fIymKzQaDcbjMZIksbe3x+7uLkkaU6/XCAIfXf/45fdHooCn4ZA8\nj2m0mjx5eMDLN17gb3zm80wmp/z2P/0njMdTwjTBMjRsSxOJNWVGGPloukKaC9+jVKQYqka4CPml\nX/410jQnyxKyNAEyNF1B0zSSKKaz3mGtUyePQ5TEJ4lT4jTBrdQYzJZohssiXfBn3/w6dz96QJDk\ndLpbKKXBtWvXUBWF8XjM3mKP99+5DVnO/SBha/s6w+mQF292GB+PmWYpeZrR98cE8xn9k1Oy2Ed1\nDcbzEdPBAj8eYRGjllU2alXGas5oNMVrWGR+yGd//PP8u7/yt/GMkq9+7Y9pr3toqoxp6uBHaFrB\nvdvv0dAlTF3mO1//Cq1OGzn1uffee3iWTXt9jY12VwQb+D4t06HMc3RVUMiqGy3q8zlJVmJ+8B55\nGqJoIBUK08Wc+WyCYxvkqc+jh/fJ85idrR1qtQZnJz1q9Qov3nieyXTKIljwtHfMrVu3VnCakA8/\n/JBf+uVf4KMH9yhLiTAQ/vZer4fneVAm2JZKt1un4prEWcho2ufuR7e4cvkaeVbywQd32NnZIQoT\nNF0/J14Vq5vps1GVtlI/p1nMeDxkfa3No4cf0azVsU2dR/uHUMocHZWYrodpVjntDaE0+eHRfYJo\nQW/Qp9lpA9BttSnKkudvPI+q6zRaTQpJZzyfsozGKIqFpKukfkZZyCKGUB3ztP8Qz6vw5S99gWB2\nyDIIOTo8RTNdzGaLCxd2CfyU3nAKGxAkBYYckmQ5iiKjyDKe7ZBLTxnSJio92lWNne1tsigk9kP8\nKEQqC8pc7LOB87F1uSKuPQOoyEJuTl7kYspTiv+LjlgU/TzLyLIcU7cpVJX5fM5aq4JWzEFpU0jm\neaGWVgmBz3Cjz2htz8aKz8RzZVniuu4qtzk5H7enqYhCNU2TMhOZ5rquIxUZhqagGQZnZ31U4nPq\n2DP+d6UieNftdksUT6+CjIRlmNimznQuUJuyqjCdzvCqHo16i8VgwFm/RxBHvHD9OXq9HpalsVwu\nSZKMWq1Gp9NhsVhgGBZJlCLLKr6/YHNjm8l4jqUKipxUSCymC2RZRZIUAj8CxLotCJY0mm1msxlx\nmmBJCopS0h+ORQzpbEae5wLVG4pDUBAsV8+vzsbWJkmcMV+Ijq3V7jIajVj6IW7F4/HjxxiGwWuv\nvc7J2Rn1epPZbCb4+5aFpmmcnZ2xsS5u8UJAGCLLMk+ePGJra4tut818Pueb3/wGP/7jn0dVFeIw\nQ1UKTgY9ymyIqghB7+HhIUka0W438X2f/miJokg8efKEk9MejuNy5coVpLJkufSZjsfYtk2vP17l\nfcec9QbEWcx0MGF39zJ5KiYmru0w6g9QLY35VGSq7+8dcuPlN/DDBMutsmmYSJKEoQmd0XA4ZjoV\n4/ZnVD/btjFNk263i+dVuXPnDs8//zyaofMXb32HmyvbGuQsFxGT6Ry5kLFdj5ZTodVpc3BwwExb\nstbd5PT4hFqtQRJG7O8fYlk2ewd75/RN27YZj8esra2xubnJgwcPaDQa9Ho9XFfEriZJQqsl9t3C\nkqcwGo2I45B2u/2xa+ePRAE/O5uwtlHlwwd7/H/cvVmMpXl65vX79u3sa+wRuWdlZVZVVlVXdVW5\n3G63PWNbLDYzSCNGGgahQQgGmQs03A1GaICxxC1IgGCE0QCC8YKxPQbbbbvb3e7al6zMjNxiPyfO\nvnz7zsV3IrpH3NEXNPPdpeJkZsSJ73zv/33f5/k9mqHiexH/5x9+mywNEVSBarWOKojcvHIDWddZ\nTmf4nrfiCccIsl4IYUQJmQwhDfHsEbKsUDZ0rFaNas2iXqlcKsjjTMJ1Fkh5QpwWHyDdqqGV22SZ\njlVv8+v/4NdxPJfd63vUGw2yDHIZaq0qWZzw+PE5jUqV2zevFX7bXKF/0sNZzPnuWR/XWRLY02KE\nTogiF3tBWQLfdynpTRInIJEicjFAo45oqPTGDjXLJIw8KlqJ3/iff4M/+a3/jd/73d/la2/dpTc8\nKopXdo4iiYhJTDCfcG17DWc+ZqGKKETEacDxwRN2N7bY3V5j5jlULYN6pYIUZxiaxmw0pHfUR62a\ntDY2mCyWbK1d4ejMY3A2pKSXcD2RTmsbQcyplGa0W2VC36FSqbK1sYuh6fi+x+HRUWETiosx3nvv\nvcfx8TGCIHDlyhUQ4eq1XR4+fIyqaVTKDa5du1bw5FOPmb5AzRI0VSZw5zx+PGd3Z4tarcHrr7+J\nbS8QhEL7kJGv8otTZrMZtm2TJNEKEZqvRlcxiixzenJEydARyVFFgdvXrjMYjzk+PeH0fMA3vvFX\nCKOn+K5HnqfcvHWD+2/c56R3RrlcIQkjAj9gMp1Sbxbj9zjPCVIB1SgRJjnVksViGSHKIq2ahbw8\nYDaZ8M2f/yWwTNyZghsGLF2Pml4hyTIOj44JgwBLk0mTGElWMIwyah4jr4AogiBQE3uM89fwEoM8\n86lXq4RhTBQlq5+3EJ8VdVu47MBXqJZC7Z6u1OFpesliLvzihbgty/MVt6AgqaVZSuj7SLJcBKSs\nduv8yM78wst6ISj80QJ+8X9cFPOLQ8UFUhW4xK0KgkCSJghIK/RqTp4JxHFKHHhIYhPf97l582ZB\nNDNNJpPRpfBQkAWSJEaTFCplC89zKZkmp8cntNc3qdfrhVI/L1Cz6+ubZMBoNGFtbWO1k7SLzIHV\n6H93dxfXdfFdD8OwuHn9BvOZTbe9RiIUU4MkzqhWmpdqbkU1ybMMWVWoqHV8PyTNQZAUZEnF80MU\n2eDF6SF5mmDbNqos0+12C/dMs4gILQ60IoFfMAqyLCFNc5rNdmFZyzJkVeXGrVvEccze3h55nmJY\nJrVa7bJwbG1tcXx0ys2b15lMJuiGipxAq1UnyzKazQaKIrO3t4vnuWysryMrAnka0hLaOMsEyypx\n3h+yWNicnh7zM9/8aSaTMVbJIMvgyrU9nuy/oFqtEccxg8GAMAypVqucnp7Saq+j6zqtVosg8Pj0\niy+5c/cuVbNEt9Pm6PgpzVYHZ7GkVmvwxhtvEMcx73zjm4wnM5rNJlGSMp8tSJOIZrN4v5+/OOTG\njRtsbm6SJAm+71+m3FUqFdI8Z3N7C8MyEXIQBIlud43T4xM+/fhT7tx9GVUrFdME3cQNIqYjm+Ui\nYHOtxulxn2azRa/XK7QPcYwoCwRBUNiJ1zc4Pj7m7bffZjab0e/3Lw8T5XKRUHlxX4iiyO7uLoPB\ngCtX9rDtBUGgFKyBH/P6iSjgJyf73Lzx0+x/8QF3b++ysXWDbrNJrWRRrdeoVxsYhoasCGiagSzA\nbPYU4oIe5McFrCInJckDZCHnZ99/lyCIQJCQVp23LMvFhzjNUWKbEJk0lfDjhNF8Ck6I3+vzlx88\nxHV9mtUatUqJ6eCU/ulz0jRG9DMe893CKpZkLARIkgiEDMsQmZzECJmIhEQSx6RZsfcQaiZyJlCR\nNTzbQU1DdDPj3Z9/E8I+hyfHHD7p05tkRKSoUkSeF+O1P//tf4yQxHzj/XfJ0wWGKlIqmVRMldE0\nIJfg888+4fTwXZLAJk8DJEyeffEVzWqFKA8ZLae06i0ePniELMjkKyZv4LpYusbDTz6jdtLjtbfe\n4sXTI44Oh1TbJVw7Yv/5nL/43occnxyw2S0hCDnz+ZwrV67x6SdfUms26HTWSMnZ3FjH8VzWqxWW\nywJE0el02NnZYdyfoBsKf/XnvoVplFgslquwFhmCEsJam/q7NYbjwlMaJjHz+ZzDwxfouo5t23Q6\nHfr9AXGaMBnP2NreYDabsVgsyPOUvSubtLsNptMZN2/eKJLn0jJZVOynR6MJR8fHyLqOYTRJ8Oid\nj7h56zZffvGIRssi8mzGwwFmqYwzWyAioSgy7Xab2WLGMgQ/i8izBDHLyEWB0WCAUd4lB+qGy3d/\ncMp73/wrdNbqHD7+klalQijKbO/uoRll8hSWnsuzowOELGev0qHSWmfuy9TN5PKz4boushximAN8\ncY3h2CNPZuSSilKp49uTVXxoEWBCXtgui25cJM/TIrdalvF9//IzIAoCWZ4ikkMmkpNShJIWqNU0\njZFVlUePnnJ9bxuyi66+KPAXMaA/WrhlWUaW5UuO9gU5yzRNXNcF+H8UeygKuaZphCnkWXaJEM7z\nnMH5gLfu38F2lhwcHFz6zUulErPZAkHIqFRLWIZO6C1Jcp+MFMeLaXWLTrpUraBrOkEQg6QRxDl+\nFCKpBrFQ4DlbG9tMJhNSZFSjTIpMJij4SY63WJKLCm4cM5qfIwohjUYDUZQ5Px8SRRFrax2iNEGU\nJXJJJUkSPDcgywptwVcPn7C2toa/WPDqK/cJfJ/lconvFKP7NFkgoRMHKQ8OH9HuFpGX5YpFvz+l\nZHXp93vYts39+6/i+UtqVYPp1MeNPETJ4ODwObVqo0gMu3qV5XJJyVBwplNMRSSOQjx7jiqkq45+\nyt279/D9kPoqnlQSiwAfWZVAnhOmGc21DuVGjdffvo8ggmyo2PaC3at7nB4f8/7775MkKY7jsLWx\nSS4UFrWfev8dnj1/wZWrm0WYi6Xy/ntfo15tEQcxpUqZMAXDrPDyez9L3dIKVvnTQ25IGqYmMxqc\n0F3fxNreYblcYntFkNCbX/86iiRxcnKCqhbWt263W+ieFgs0w0QzDGaLBYamcP32LdwwYufqDbb2\nrjGfLQuRcRJh+z67e8X7tbW7g59EyIrGfGHTanYKt4ooEgQO9+/fxwuLA5IoyDTaNV599VX6/T5R\nFNFo1i7v6YsDRRRFBVp7NRlRFIXuWhvIfuza+RNRwP/L/+I/Znv3BnN7jmUZZFERbpGikScOYRiR\nJC55BoFfeBOX3oI49VB1mTAVi8hRWUBWDQI3QLIskiQjTlLcucNoNLpM9prNFsiixPPDAVmc4Llz\nfG/J2++9zdPD55wM52iKgpxlCGSQJqiyiK4qZLq0sqwViTmSAJJcdCOpUCLKCx9tGMeomoGsKvzU\nt36OxnqHBx9+xP6nX/DGy3e5e+c2P/vNX6A/fsazo++wvbHG8OAPMQURURZJ85jAzcjqCf5yzJWr\nN8jznO9/9w/ojc6oVGpIeUaprCPlGVkuMJhM8JZTqrUSk+mUV195C6teJVVFUhEmvSGVcpOSbtDz\nJqSKjOPEaJpJo9kmShJu3rzJv/93/zb9yZhPvvqcna2bBI7Do4c/QJZFTs5cFEXizTffxLIsdq9c\nw3EcFvYcRIEgKqw6F8Vic3PzMh+9WamxtOcspzazdI6qqswmE5AEGpU2s/mI40EfP4iRleJmd+MQ\nb2JTqVSYjGeYpsnJySmlSpl6vc7BwXOazTbra5soqkS1ZjJfDNm7co0wTAjClNFwiiTozCdniIKK\noJTpDQoi3HQWIggLypU6/dMZzWabzWtrxOkARVJQSjrz6QzNKNEfnBNnCZkYopar5FGGLBee8Ub7\nKl6Q0m1IXNnrcLRzi3qjhSjmbG9vkfkh5VJCt1RFkDXOh1NuXL/JfOawnC/oHz1GVjXMSgMvlFCl\n6DKWklygnBzgq2tEVKiXQja2togzSGZ9Ij8gyy4Aa8JlMS962aJruHfvHg8ePCgmQIpKluUgrnr0\nvCjd+Qr2ksUZqQBCLuI6LpIik/mrQ4UgF7anFaClOBD/MG3sYrR+8bWLxLYfLfIXf754rSiKqLIC\ncYqQ5Sy8JbKq4TgOvu8xnxf3Sq32w4ejbduYloUsCyRRiJ3ESCQsFgvKlRpHJwesb27RbrfwwiJ7\n2nVdVMNYdakunh+gqNolGa7ZbDEej9nZ2WE6nRJnKZZlkSQpsqoQxhGSIhP5DvP5/DKb/MWLF/hR\n4csPggDX8y8PTRcH2DCMmM8XnJycsLbWLaxwmsZ8PscbjdB1nSTLaLXbpHmOpqmIIsxnS0RRZDwe\nMxwOeemlWwVkqVZbjd09fL/Yp957+S5JVhzYojhAEHPSOCGTE+ypw87ONr63pFarYa8O12EYF2P+\nMCTLEhqNBkvHJU5AMwqNQ6lUpq41CEO/sCoCqq7hBSEZYsFSr9So15ocHD6n3W4hCAJHR0cA7O/v\n4/s+29vbjMcjarUKzsJhPp9SrdWIEzgfTSgb63z51WOu7O4WNEC3mKqdnJyQyyZREnPjejF18EMb\no1YnjmNM08DzvEsb6PbmJqKssnRsJFVFlpXi/U0SkizmvNdHUXUEIWc6n2BZFkHocNY7otstMtIl\nVUDIRJI04vjgkPv375OmxcQpCRMEZDqdDrVajclkcpkulsQZpbLJcDhcBcfkzGYzPM9jd3f30r0R\nhQmq9s/JDry5ZiCqMcNJD9PXkfMEx7ORtSoqkCMiqRJJHpMkGQIS9XaXamOdJO2TZQqSKKDIKX4Q\nYVWq/Df/3f+I4zgEUXJ5kyurXV3oBwiKSiabkKdocg6yuMrEjTGzGClKyaMITVYREYi9kExNiY1i\npJhEEaaoEPkhoqyiiBYlpU2jYrLwfaQ8J5NFIiljlGYMn75gfXuH+/fu84vf+lm2N7oMToc8+OJT\n5osTmlaVVJAJo4A0S1FkkaqSoSsieeZzPuhxeHhItWRR77zE73/7L4uHoCig6xZRluHHCY1uF8tQ\nUHQZKVEYTMaUO03+4P/4A1q1OrEXcP+117h99SXW19eZTqdIacKwbKEaJs5iycbmGvVGmXt3trGM\nFt/5i+/Sqr2JokgsFwGapnHl6k2yPCnUpceHEOa88srd1T6ysGyoagdVVS8DEJyZje+FDM6f0ems\nYZYlgigjSSKWkwOixMeqWTRaLeaz4tAliyKqauE6Po1GgzRNabebiLKEunIQdLtdlguPerON680Q\nJI2Tkz43rt/hxeE+vpcShkviKMMwJA57Z0iyyuCojyTIBEHMfNaj3SpYyp9/+RmGYdA/H6BpBu1u\np0iUUiWsapU8k4jJsHQVRVfQsXCDFFUWuXO1xMGLZ0iaCZJIqV4hnIwZ9/ukwHg6J4hTZMng+x9/\nSbezARlEcch8eIJZaRClCuKqkzR1jdnCQRaeQP0tMqmC55ygiCrKSnWb/sj+WxBERLHodHNAlpWV\nBgTW19fp9foIQgqCgEhRPC9SyNK0QLGCSJaklEoVojBAkVUECsY3okSW/HC3fdFNXwBcLjpv4LJg\nX4zSL4p2kiT/TFY4FKrsME2xl8vi7+QJiiLx/vvv0+m0Vq8pYDpZmtNsNjF1mdHonCxKEaSUeruK\naZgIQmFRVFWVMIlX31dAs9lkMp0yGA4pWRaSVLAIqiucqO15q4xxF88uBGZxHLO+vo5tF4fIBw+f\ncGW7sCrlwHy+4MaNmxweF1QxQzeZL5YcHZ1w9+5dJKnwyJfLZTRN5d69uwU0JgwpWRaVSoXpdEqt\nWeA1bc/BKJmFRz5JWFvbuEw029zawbYXTKZzzkfnqLoOosh6Zx1W4SmqqpOuKHknx4c0GnUUpbBJ\nffX4AZIkUK/XCaPRahwdroA7KaWSdTl+V1UdJS+cN5ZlUSqZTKcuoliEOG1vb7O052i6SRqnREnG\n0pnihzFBVAgFt7d2cH2P5XKJoiiYpkm1WuPg4ICaVWU2mSJrCkEQkmXFYSTNMyq1Oh/+4HtoskCt\nVuPo9JSrN15ie2ujEPNlKXmSMs2mlxGjW1tbVCoVbNvGtm3K1XoRTFWv49oOk9GI0u42cRig6yqD\nQZ/OWofbt28WeoFen5JpcPXqHsNhsQbY3tzm+fMDGo3a6rnTJidB13WmkwWWZTEcDlEUhY2NDZ4+\nfYplWURRSBxHzOczHMfhyy+/ZHt7h8PDQ5rNJsfHR9TrVZ49e8bfeetv/li18yeigNtugpAHlBUD\nYtD1BrKhkCdFYlgBGhKQdQtFyZFElV7/AEVtoBkNpguPnAxdF0BIQUj4/LMfYJql4uEjQsWQEPKU\nOArQTYUk9bBjB90wyLMIQUgZD89wphPkXCFKI2rNBgvXQ9YtKnsNas0GS7+gd2W+z2ywxIsF1ts7\nbG3tkGkCfhiiGBGqJKJIIkoa0c4Ndq60ee+dN/GWDtP+IT/409/nyeMn3H91C8W3sO05yzRn49oO\neRJwfnhGzQRLU6mULI5PT4v9mBpjNSsMB2N8PyTPZHw/JyLnrHfOxx88p9NpcO+VOwyXLrGQs0hd\n7r/+CiQFwKHTaWFpOmdHx4RxRJbE3Lhxg95wVMRNSgmD8RnVksRkOMIoSTTam4UvtiGytraGoqmY\nRple75hytUS72yqwmorCWe+k6Bz54UM+imVeHB0VjGXNwgtiHG+CWTKRVQV7OUaS4MMPPuDVe2/y\n/PkRpmmyttbBLFlEUcRyuSSKInb3tnn2/Dlra2vsbG9jmBYCCoPBgI3NDi9ejDk+PiWONURJp1yp\nIDoB8/mIg+PnGKUykmzQbGm4tsNiscD3wgLcYQpIsoqi6uxeaRewBVEEWUJSFURFQUh0VC2nooEX\nOIRYQMb1DZM41uid9biyvkNZ8jl+fIxvR0iijCLKLOYOLw4PmU4WCFaF4ajH3uYOp/1zVEUkiUNk\nRQNJJU8KOlaai/juGNk4JjGusPRlHnz1EfdefZ39Dx3yJEUSi3FdlsfFSB0gp0AMIzCdTlfKdPEy\nxCRd5YAXV9EhF6vuFMM0C3xnHOPYDopSBiBdvfxHd9sXBfyiu74A5MRxfClWu9iBh2FYcLg1rbCH\nrb528fuVpYLKdvFvfPTRRyjCXWRJoVYv9or20kHTVWoVkzxP2V7bIIodTg+eI8k6mlXGCWJyAUqV\nCpVKjV6vR7WaISkyhqwgyTJikhRTilUnK+ZQr9QRc7FYv2U5mqbg2s7KdqRy/fpVSrqyitosvMqn\nvXMajRaz2YzJbM7t23fYvXLt8iBjGdqqGHdZLBbIslyAoXyfcqWCVSoTBAGaoaLqCgISIiLudEoY\nJ6SZgGaYuL5Ppd5AVGTiLCVOMzTDJAgCkiQjCKIihjTPCYMAXTcZDIZomobnuCRJwksvvcxoMiZK\nEyaTMbu7e4Wq27EL26IXUq+3qFaa2PaCZqONJEkMh0MKK7+I53l88PFHbHTXWCwWaJqO54fEUUy3\n2yUMY8bjKdVqlTRPUBSNxcLm448/5er169i2i5AU94k795jZS/7wD/8vVCVHkMSVL9zkqwefcefO\nXXau36LVKvbRSDKtVgshS4mTcAXnyQjDIp0tCsLCVjacoJnFFE/M4daNm0VCnueiKTJXr+2Spim6\nWiTl6YZGTsbR4QG1Wo3hYEAap5TLFo1qjZJpMRoPSLIUTSsOzp7nYds2uq7jusX7++DBA0qWXtAX\nq1UUSWZna5tmo4Gu6/TOz1EUBVXVL5+RP871ExFm8uCLD34tTiL8OCSXcgQ5R0BG1crImoSo6mSC\nynA04/HTA77/gw/5gz/8M0ZDmzwDP/axvSWkMVVNKCD91QaTxZKlW1gGJpMpnuuhayqeZ9MfuFi1\nMqphEAYJb3/9HebzBQ8ePGFjYwvTKvPX/+a/ztlkzt7tlzBqNURVQzdU6u1NZKvJ4LRPo1ZB1RQ6\nlRq6WSbNAjrdGuvdOhutJhs1i3/73/zXWG/VOXz4Mc7wCKOiYhoyN3d22Ow0ET0X2VDJpRoP9p+T\nejZiklO2DG5tN7lydZtyyUISY/qTAd21TR58+RWLuY2fxsiZgkzCznaHvb0tOp0GzXqZ9nqXW7ev\nEzg2JVPn6tUrKKqC63mc9XpUyyVqJZOyZfL8+BhBU/DCkIPnT2m1W8yWNokIg9EAz7Zp1Ku01tax\nTJnT42fY9oxSuehEcjK0VbDDYrG4HHeGQcx0MsP3A0LHYzlZcD7oE6QhTuxwfHqCIshkUoai69y8\n9RKKqhJHAZIksLbWRVY0BCFDUUVkWSEKIhr1KnHkohkmplVBlFRmiyWPnjwjTHKuXX+Z0WTJYu7x\n9NkBk6kNgkQYRjz+8isURUKRZGbTKYu5zcbW5ybwGgAAIABJREFUJqIkICsKu9eu4ccxZqVGKooF\nF18zkWQFchFR1FB1iViQ8VKNOJGpVzVu73R5+OUnOMuA3SsbPHnyiOnIZTRaMpkt6A+nuF5AGEZE\ncUISpSiSTJLGWNUq86VDtVpDlDWSNMOZTQjjHEQZSVNQxJxQu4aiaDz47v+OVTZobu6SSwqhH0Ea\nIwkZkJALArmwigDNIYqKcIXRaFjkgK/W5Bej7zTNyLMiWlTXNNIUojDENHTWNjqUyjWcvIGcB1ST\nF5eK9otR+YVY50LxrmnaZXd+IWjL88IPfjFuVFUVKL6HNA9QNAVFllaHiwTbneH7c166cRNRljD1\nEmImYGgGpYqFKAk4voskS/RPe6RxzmS+JBHg4ZMnNFsdmvUarmNjmQau7RJHOapSePb9MCDPEtzF\nAkOWqZVLBZ0sitDVwgqIKOGFIYos8cnHH7K3t81oPGU0HrO9s02SJni+j25ZnA+HlCsVhJWlzjCM\nFSs7IIkiBLGg3zmOTZanWCWTKA5RVRlFlS8PM2maMByO0Q0dx/V4cfCC+WLJ9s42UVyo4uuNBoqs\nYS8dECUcx6VsWqhScZAL/QBD1RkM++i6Rv+8z/r6OvV6g9m08JUnSQYCq85dI43BMktYpkkQuYiC\njChBvV7H81wajWYhOEwSrJLF0eERd195g/XNXZwgIM2hUqkTxDFWucxkPEXIRAzdIopTXD/C1DQC\n12Nw3kPTVPq9Hq+8/DKGImNWK7z++husr28gSDKvvf51JMWgVqkSRQnz+YJKqUwSxWRZTrVSJc4K\n/ZMiSXz++eeIgsizJ8/Zf7xfUO/8oNBsRBFkcHB4QLlcxvcCSlaZgxcvODo8oFlrU7JMBoNTyFM2\n17c4Ozoj9ALOzk74rd/+TVzfZWdnl+l0xtL3kFSFze0tjk97HJ0ec9br8eDhl1QrBusb66RpwmBw\nTpYXjJJmq70i0LUQBJF2u8vmrbd+rDCTn4gC/uLBd38ty2OskoEf+6DrnAxHHJ6f8+lnX/HBJ5/w\nyaef8MmnH/Ps6eOiK1SNgmYkiyiqQhD5CHmKJkMQxUSJRLnaYmPzKtdv3uPdd7/Bv/Qv/jX+5E++\nw8v33uQ//Pv/EeOZjaFX2Fi/wvs/9XP81m/+Pp6fceXl2wiaTiIo6GYVVdWJwxxS0LUGgihRkWUq\nScRLt65x784tGp0GVVPh9ZdvcXVnDZUMIQ4QkiVXtloQLSjrOd12E9u3UckhThhNhvjLKeV6GaXU\n5cGTF+RpihAnaIqIJsO3vvU+fujiug6D0YB7r7zKcukwHI7ww5gogDiM+frXXuFv/Ku/wvbmGpub\na6iyxny2wLJK5Dm0Gg3spU0cRViWhShJLBYL+ucDjk7PuHrtKqZVomRZ3Lt3D8dxadab7G3vISEi\n5wJR5BGHHoYqkwugajqyomA7NkkcMxyOCtKVWWa5sOn1etRqNcbjMZVSBdt2WOuusdZpEUcBa50u\n6xvrzO0l/fMRoqQQhDHNdocbN2/QPx9wdtYr7EaaTqVSwzBNciEr4BuZhGv7TKYLumvrjCdjruxd\n4fSkjySrjIZjDLUYa4LAYrnk+tVrCLJIHMVUrBK1ag1BEPH8gChPQNXIBUhXhSbPASG/HAGneYpi\nakS+hyCZxInAla0ahpBwcHDKw0ePmMw88tzADVIkWSVHZLZY4rguoiihqBqO44IorJThErpuIEky\nsl4ijiPEPECQRHRJQlA1ylbOUrxJLuksJocc7X/F1955F1WUCIMA17ERJYF8tRC/2FWLYsE5393d\nYTqdFTs+SSRfjdkL8EuRUiZJEpIoEq0CR0RJ4OrVHUyzjJM3kYioJk8uRWZpmqKq6qWi/DKda4Wo\n1XX9EvByIXC78Iq7rnuJKRVFAVU3CP0I3/WxDIMw9rmyt832+gaWaaJpOkEY4ng2lWqF0WQMooDn\neyhqERaUS7C2vsnO9i5JFBOFMbPZnGqlxnK5JE9BVGA2m1Aplwp1tqqRpTH2ckm5YuH7Do1GDVGS\nmS/mVMqlwqoUpyiqyny+QNO0y3zqNE0RgLX19WIHvkJq2rZNuVzGNA1KponnuZeHHFVVOT09RZIk\nAj8iywoQz/n5OacnPZrNJp9//iWlUglVVS+pZ+fnfZIkoVQqkWUZtm2veOzllTAxZzQaMZlMCneC\nUKwbiiS1HwajSJKCbhhIsojve+i6RrtdqP29wEPVTVzXZrlcUqmUsG2bJ0+eFMK4UglyGI1GqLJG\nkiZEYYTrOOQraE8R3FQ4fgRRYGOjy8nxEfv7+3z9nbf45OOPiZMYBIHjkxPKpTI/9Y2fptUqVh+K\noqDpajG5UhQsy6TZbDAeT3BdF8PQkGRhtZfPsQyTLMvotNscHh6xu7vLzu7uZaZ7mqYMh0M2Ntbp\n9XpEUeFYefHiBRsb68xnC8qVEmHore5flTCKefL0CY1Wg2//6bf55jd/hiRJcV0XTVOplKuEQYhl\nmUzGY1x7wc72No1GAQHLVwCZUqlMtVZD03QkScZxHG7dusVoNGLnzjv//08jc+Iq0/mc+WLI2dkJ\n0/mYs7M+ruuhSBXIU4Q8QSTDUEwkRWB4NsITbNY6XdJgjpwnlMsmaRoRhAm/9zv/C2EqEOUyilpi\nNpkwHQ547Z1v8Nqrr9IbJ5iVLSo1kc31Nr/9u/+U08EYw9R4+GCfdqfDw6+eohjmKmmsYEw77hhi\nHzP1eev+y3zt7df57C+/z3w+xSoZ9JYnjEZDwjhgfXODd9++S+ycEi4mOO6C0XCK3qgjxjFarpMK\nIrkooMkCpB62vcDSdExDK/bFoynVahk/WKIqArtb28RhxHq7jbecUFJyfupnf54vvvyYPItoNiqM\nhz7OwsVZka/SNKVZbxAEUZGNbli0Ok3K5TLPnr2gtbbOS/deQdEKFOY4idjff0qSwHLuEng+i8mY\ndrOJIqdEnodlWSi5hGEYNFvtIqf30SM830eSVfrnYyaTCfVqreAcI3Da67O2vclWd71Q7Zsmkqby\n/OAFVrVGs6vieAXAIs6WuK5PmuYrVnOKqur4fkilUmFwNmJpz5FEA9vxuXvvTQ5enEAiMhzMkSWN\n508P8R2XW7deYr4sRlzVahVRkWnUyixmC0pWpchtTzLK9QaCphCRoRgaUZgUYso0RUS4HBcbpo4X\nhWiyTJCudriyzNHJM/xghu/nfOf7D7l1e4+17hpRnDIZTSErsqmzPEUQwDBMkrSIm3Xmc+rtDrJQ\n7JpFSSaTREzdRJYkdFMjcxNM7QxX2+WVd36OP/+9/wl7bvPRX35Q5HPLMlkWkeVCkVAGCAiXhLYw\n9Nne2eTpk+dkaUq+snBdXBdJZUU3La1GsSGNRp04DEApRHEXBfrCQnYhVpNlmTAML9nn3srqWYSu\n6JdF/yLJ7MIHHkURAilJHpHEKYIgIokKoiBhmiZB6BcBG7VGMS7OEubLBa3uGpValcT3CXy36A49\nCYSCIieLMkEQkiQpvV5/hVYWUESLJIro9XoYmoJlGTjLOaIIrrvAMBQ8z2E4miBJBa9aVdVC3DZf\nsLO1jawqLJdLAKrVgiUeeB6qLFOpVC4tdhejVkEAUZAJgxjH9lhfX2d7axcQVgS1BDKBne09Tjgl\nCKKiew8C4jjm/v37RFHEfD7HshL2Hz2m0WiQRDHd9TWyJEVTFEqlEkdHR5e/g4srTVOiKFr524ux\nsaZpJPkqBCVLMHQVz3cRRImzszO2NtbY339Ev3+GJCkoiray/RWpaXfv3EMzdOZLG0EQCm+0pmN7\nLpVKhTgOmc+naLpEr3/K2nqHTrdFkiS0222yLGNrd4cffO/73L59mwcPHtDtdleiv5DDw0NMs/C1\nr6+v8+zZMxRZ4/T0GFHKcD0ZQ9NxPYd6ucLO1jb1ep3NjW1s2yaICthKrVbj8PCwAPgMBmxsbPDR\nRx9xdHRE4EfU6zabG7vYts3JyQmmaaLIBlGa0F7rsrG1w7/3q7+KSBF4IooC9XphYZwv5jiOw53b\nNxGEmyRRjB96qIrO2dkZpqXTbrc5PTsjTQtaoaqql9qCH/f6iSjg/+gf/RPCOCKKArI8YXtrjSSW\nKJlNwjQorGJeiBsEzMYz7IXN9lqT3U6XwaBP7KdokoAma+jlEqU05y/+/EOeH/WY2j7LZYBt22RR\niK4ofPjBZ4TSF8RRwnw6Ib13l+OTM6xyiVarxXzU48vP+1Qa3dVuSsc0TURZRpBkzDjjfDnmex/8\nEb/73/+3RPMzdqoWfhLy7LNPuXltj9tvvkkqCSSew1H/mGDRZ2NrkzfeeJ3ebII3HiPlMdu7VzkP\ni8OFobRQNQU/iKiaBpKY0Gx1CjtCFrG23qZRb5NmEuPhOVtrHX76/Xf4B//5P+Eb33yNPAkhS1ks\nFoVAJc0uH8ilSpWjo8I/HoYhJ2c95rMCMbm0fZqtKodfvaDT6bCwXZyFw+bmNseHR1imTq3WYG1j\ni9H4lDiB2cxD1jSi4ZTe2aB4GCNhGSUUSWU2nSDkIqPRhNPjE+r1OppuMvN8eg8eEHk+QpIxtRfU\nWk2C0x7z+Zzt7V1uXb9BkiTY9gKAZqMBFHacer2CYRh4XhvTLOF7CdvbNzBUnTwVMPQKcQTTiU21\n1qBRb+G5QXHgUIr1QaNa4/nRIWvdLogSRrlCLskESUy4ivFKgghNKXjpgiggrRTTcZahZAlkFCpm\nowKkjKYeeRQRhDGqJqIbOo/2D5kuHExdJksSDEUFRKIoKMSHikIExEHht47DgJJZ7MVEUUY1rIJf\n7XukcYYgJJjJCa62i6K3efP9b/DJ5w95+fU3efr4IZG7RPgRJKooKJDHCIAgFqlIpmXy9MnzH2JX\ns4wLv3ieFl14sRdmlUyWoSgy2UrDliOiKP9sTGiSRD8Uzq26ciioYapa7AsvirUkSQRBcGlBu+iO\nZFHEXbpkqYAkKkynM7IcxqMpliwVudVkxR48SciynOVswXwyQ9NUfNdjMR9jWjpPnxagkjwTaDbb\nl4eLo4MXNOo10iRCVxWG4wHbG7ewbRtRFDFLJvv7+5cFWRBkms0mSZIWgkqpsG+mWcYH3/seW1tb\nlyrkJCnETY1VfGetVsN1XXRd5/TZKaIEjWqN6XSGqqpEUbxS5hfBI7PZDFEUiKKYa9euMRyOuXfv\nHtPplHa7fan0v3//Pr7v4hgOs9mMTqewr+VpiiQIjMdjbty4wcK2mQ5HyCvaV6lUwvf9ywQ53/dR\nZJHID/CcJVa7Te/0mLOTHksvYH1zm0eP9mm1OixWoSfVSp3JZMLDrx7z0ksvkSQZi8EYUZHJcgHf\n87BZUmvWWSwWLBYztrbXKBkmuq7i+z47O3t858/+/NLPfXp0zNe+9jUGgwGbe1v0+/3L9K/nz5+z\nt7eHIAisrXV49Ogr1tY6yMpOwWjPciRZpFwpphT5SqBxdHxAEmfUGnXm8/nlmkcURY5PztB1nVqt\nhqQo3Ltzj6PjA/b399nY7Fyq+x3H5c37b/LHf/zHnJ6eUiqZeCuv+Xw+ZzqeFHqDLKN3eooIVKol\nlstlkVCmK2h6MWk6OTlhY2MDRdXx/XPStLif/rnZgf9n//A//bWMEEUHU8nInCmWnJInLrGzwFtM\nkXORWqXN669+jb/2y7/Cz7z3Ctdv7PDhhx8iCAp5IuLaXpHcYxjYcc6jZ88ZL5aM51PcwCaMbJb2\ngCzzGZyPsO0ljr1kOOizu7tOs1Fm78om65trnA8HlEsV6uUymiAwGY5I/AgxSem02jw9esav/b2/\nwx/8xn9N6E+YuWMCZ8Hbb9whDReIUsjcHvHk2TMCx+WNV19hZ/cKo8mcZrfLYjzi5Ru30FotZqMe\njx88YPPqVfaPhvTOlrQrBqQJcejxL/ziT7O52SEOQ0RZo93s8O0/+iOuXtlGzX2arTUkKcMyZEqW\nwaPH+9iugyTJl+rJP/3Tb6NpKltb2ywWC05OeqtUnDaaplOtlUnThNFoQBKndDpd0jSn1epSLpdw\nArfYNyomslpi58p1qrUmeVZkh58cnSCJEr4XMBgWN+doNOLk+AzPKzjKL057jL2A4WzJ8Umfp88O\nePr8kAyJsiFSMU3u3blFHPp4zpLtrQ1KloEkCrRbTZaLOYqqMBqNUVWdKEw5Oe2hKDr9wQgEiSwT\ncJyQxdyh0WqQw2oKUfiPl8sl4+GITqtFECcc9/qUm03CPGXhOhiGgSwrCHkRrCFQqJ9FWSbJM3Jy\nVCSyPKdULpFEAUmusHRD2s0yzmKOIIuMpzaSIhP4LnmSIOYCiiiRJBF5miKLAlkco0gSaZIgSjII\nIqKQI5fbCIKIrubEYYysS2QhiEKMoeVMxWvkgkYYDrDdmPF0wit373DeOyVPVwEiubDK+s5JspiS\nqXP/9ddoNhocHR3i+T4XMaKFgn1V0YULNbtMnmdIkkC73aBWrbPMW0hCSiX6Ck0r7G1ZmiHL4qpo\nC5fe14tiDlwmBV5gVy+sNBd6CUmS8FwHSVJJkpQsyZFVCUkVWcymrHe7aIpKuoKfuAsbQ9MQBZnJ\naIahGaRJgmkaNBtt2q0WaZqx/2SfLAVDNzFMnXqtiq4r2IsZe7u7l5qKLE6YTGbkmYgkaZRKVdI0\nIwiLldB4PKXVagI5Rtni7OSM2WzG1tYWhmHw4YcfUioVh39FUXBclzQtBINhGHF+3qdkWiiKiqpq\n1OsN5vMFum4QhuHq/RYQRQlRlEjTDEGSiFf+4U6nQ7Jai+iagud5eJ5Hp9PB8zxGwyGVUhnHtnFd\nt1hNSBK+67G+sY4giMRxxNOnT7l56zqOa6NpKooooShFWmOWZgRuQKVaxTBLvPTSnUJ5X67hOh6W\nVWJzc3M1AauyubnNcmkzt22CMKJSqVCp1pjP53TaHWRFplar4js/BOSYuoHr2CiiTLvZotvpUqvX\nC8+0JNPd2KBWq18WyevXr3Pt2jXSNKXf77G3t8fx8TG9XrFiSLOM2kq0d97rk6XpJROif95DFCVu\n3LhxefixSgaCIFyiVzVVIQxjVFVhPlvS7jS5cmWnEFgGcWEjVVWiIERVZGazAmHsLO3L6UitXqHV\nbuJ5xWqiaBQkfN8jTTNc28EwNXw/QBZlZvMZ1WqV58+fUavV2HnpxxuhCxcfsv8vr/de3sw1S2Fj\no0Or0eCtV94jQaC7vc10GZOJIodnQ06HSxaOx/DkBT//eoOzo0d895OHjGdQkip4ixFWTeHeW2/y\n+OGAIE6wtDJlS+PhZx/w13/5r3J9b4Pj42ccnc85nbvUWl3W1zd58WSft++/yheff8b1rS7f+f73\neePtd+n1evxb/86/y5//4CP+8W/+Dt5ggqLCP/z7fw9DmnH/668yOuvTqrfR5CKYYmE7qKqOY3s8\nOzjBKlcx9Ax7MUaWVNBEtltVci9CKpucDU758Dt/SaZIfPFsylePzimVDNZbdTZqKr/+n/wqy+kE\nP4wI0oydK1cZ9XtMxyM2ui36M4/Ac6mVK/TOBmRiRkAEicTt27dxA/dypDeZFGk87c4Gpm4AIkkY\nceXGTZ48e4ofhaiKRsmocNYfFhnBhkQqZhwdnhCFOZVKhdOzEwwp4+ruJrVKCatcJRPkwnKRJERR\nQJxkjGYLJgsHP4j56vEzclmm1ahDGLK7vcHe1jqKKDE7O6NULWGWBFqdJtVGE023kGQVVTf5znf+\nAkGQsMwSi4XLWncbz404PD5CXKmfFwub4XBIrVbHMHQsTScJI0RFRpQkRE0hjIp841qjxWnvDFHV\nyBCo1hvFuNMpkuEMwyiY3iv708U4UpZl5FwmlWKSwGdjvUOpucOnnx+wvdkknPb4/vf+mLOzJWkm\nUK5YSEKOoaioShHFapgqQp6R+AkZOYqmEqcJsm6gSgLV3deQVAMNB0UWiYOMTHEIMh0jSRiX3sPV\nbtGuZDz69M9I44jz/gmj83MgQ1j5uQVAliWSJOD11+7xyqsvk6QZBwcnfPcvvo8kaSuU6upaWciK\nsXqGKEqAwC//8i9hGCbn3EHKA27Ev0meiSRJkZwVJ8UKglxA1X5IWrvwfl9khV9Q4C5oVpIkXVqk\nDEMjSjJIc/KkKPgLdw5pwmarBVmIoih0Oh1EQaZerxOEHoaqEYY+o+mEeqOCpRu4rkupWiFKQlrN\nKnkmIAkCpqkR+QuiKKJ32gcxpdc7Z770eOP1t1b76iKnPs9zzs+HGGaBbN3Z3qTZbPLi+AhFkahW\nq+zv7yNJUtFdKUUAR7YCuNRbTU5Ozjh6ccC1a9eIoohut4vv+wBIUiHuOz8/xzAMbt++zcHBQYGl\nlUSWy/mqqyw6dcs0Vp17hLTKeM+TlE6nw2S+wHdcKqUy5+cDDMvkBx9+yP1XX6XTKXCp3W57lZZ1\nxNbWBqVSicALmS9tREGmVqlTKpV4+vQZZqXMyXmP9c46GxtrnJ2cXvrZq+Uyg8E5uVBw2sulKns3\nrpHnOb2TY5b2nDCOyZKIRr2CJom4XsB4Nsc0LKbzGVEQUqvV2N7e5fz8nLN+j1qlSmetW1DoKNwK\nk8nkMjd8f/8Rz54941d+5VdIkoTz8yG6adLpdJjP52x2O0xnEzRZoVap4odB4bhYTYqm0ykiXGoQ\nLsBGSZJQb1SZjOcoisxo3OfmzZsEfoJhGIwmE4bjMUmSce3GdTynKNRJVHj9SyWT5WLB2toanl+g\nauMsJstAkhQqlQJopak680Wx5imXy5cQo1e/9bd+uMP6f3H9RIzQ/42/9bepN6sYllqMX0cRVrlK\nGCuMR0OeHDwnEUXmfsrR0QndikbbkphrBTUoSnXKtSrTfo8bt9eZz8bodZWvPt6nXavhezqvv34b\nxzlnaef8wi+8yz/9/e/wd/+DXyVGpt/v8y//4vuE9oKXrq/x5t0b/NIv/Qztdod2s0EQpexu/RJ/\n41/5Zf7X/+G/4vbdm9x7/SaZ57P/1Qlh7LP/5TOeHT7Gj1I2N/YI/ARZlBhNxvhxxObmJlnoIuUZ\no+WEQbfNm3dfQ8pTOt0u86VLtVWlUa3QbUZMFnMUTcUyNE6ODtBVA9MoEXkOsiwyHA7RZYmFE+MF\nPmkcMh2NWWu2sSOX+fCYQW/CdDwqRnGjMYois72xwXw+p1zS+fyTT4iihL2dK/z2b/8Om1s7nJ0P\neP78ObpmsZgXrPlXX7vDo8ePCeKEKIzpn/d4/9132Fov1g2Os0Q1DWrtNo7vE3iF0CUKIxaOzaOn\nz3GCCEnTib2A2fmQnfU2ipDw0Q++y9WreyiCjq6b6CZs/t/UvVmPZel1pvfseT7zEHNEzjUXWVUc\nJJINkqLUMKS2JAO+0I2B/if6E770jY22r9p2u2G4LcuttlpuqtFUsVhZlVlVmRGRMceZhz3PvvhO\nhKi+NG+oAyQSCERmDGfvvb611vs+78E+Z+eXnF9/xVcvv2G5CjEME9tq8O1PvkNeKayCjDDI6Pa3\nUFWF5XpFxZqHjwVjeWt7gBIjPKiGziIUAi80GavVYuovkXRBDvO8JlVZU26oZYqsbqJdjfvio6sq\nMptCrmkoGqSrmEGvQbApgpZlsIh91qs1timjmx5JklJLJbpnQS2RFRm2bAhSn1KSZyWqJKMZGoZp\nEK2XWEmIpVtUCFukrOdUdQPPrESBLy4IecbcL/js538NgOM1cD2xe83TBEWuUWSJvCzFLlyCuiyh\n4n7ELZq6+wgzkO5wrCJyVHTOMmfn53z80UcQQi1tREEFm6mGEMEZhkFV1vfF+w6netf93InX7uE0\niIf0nYit3BQqSZNFalmZ4zgeVZZhmjYNt0ma5Dz//CWPnjxm5a8xTZ1I10VnpSo0W21UuMftSrLM\n9c0bPNdla2sLynIj6CuEpzwO6PUGbO86TOczWp02kiIhydBudnAbTa6vxjx79ozx7QgJhWajQ6fr\ncXNzw9HRkdjRJ8l9dGqSZYBMmZUMe33qotzoBUpGNyNM20KSwHXb5Lk4lLieje2Y7Ozs4Ps+UZrQ\narXE72xT6Os8p8oLGo5NnmVohsn19TWGrlMXFcP+YGNV22I0GdNsNjEMg8lkCtQEm+CUBw8e0O22\nmUzHhFFCnKY4jn5PLYuTDLNR02q1uLq64OhoH6Savf1dPv/lp/T7gu/ebLYBiXajzdX5Bev1EmqR\noKiooGsay/kUpa7Jy4qm62K5Ht2tPm+OT+kN+swWc/rDAb2tIevlkjzPef36NYYhMtYnkwlff/01\nu7u7pGnO22+/y9dfvxLwFteloYuVFMjcjG5RZIk0Cvnss89ot9vs7Ozerww6nTaL2fweGmRaOrJU\no2yipg3DoNfr0um6dLs9wiDFcmxMz8F0HTTNYLFakWYp3XabIlE2YjoLSZY5PjnBazUJgohGR6jm\nW55FGMVoloVheuSLgOHWFrZtc319fX9Y+U1evxUFfKvfJ8sTojCkVkI+/NHv43kO/+Jf/Hd89sVz\nvnz5gv/mz/453zx/gbr4ilVkIiufICsGmq7SVj1Gkxs8T2N0MSPJLvnTP/tDjHTEzvYBP/zh7/L2\nW0+IogW9hk2wXPLWt77Fd959zIvjE6KmgabJdBs9et4RX3/zBQ27y/GXX6A/PWQ8mnJ+PaaSJXY6\nHnqW8zf/+v/ily9fMBj2yeM1cl3gOk3ef/8Zjx48otvv8c0336DKCq5l8/L4mEcPP2E+vuVHXQ+k\nkt6wT7fZ4NXZKZLk4xoe7zzpik75F3MszSGrJNZhjmZ4rAKfNEsJVmvhPx1P2N830FWDr79+xbtP\nnvHm7BjDceh2dsgLQa/aO3qArFsi1q/ZI0pyRtMFBQpe02O2WjNfr/jk6ICwrnioKcwnSw4OH9Ds\nNCkVBdlpIYdznu7v4ugmw7bD9OqMxXJMu9Oj3WxhGCqLSYBpOhSZwuXFBAkdqZDQStCVil6vwcH+\nLoaq8eTxQ7713vtEQUBVrGl3TQ4fPOLy8pa/+Iv/gG46TMYBRw8e0O8Pmc9WNOwul+cTri6/xHYd\nNEkmTnN6vd69xURRVK6vxihIBL7P0dFXhCx4AAAgAElEQVQRbavLZLVENy2m0yma6eA1OiLwYpPI\nlabJfUAKQBJF96rsuz1qvUmKkuoaxdBZLtZMRFOFqyfU6Zw//q//mNHJlNenV8zrBaYCSSagPIap\nC9FXXZFnORI1EiWq7mKZGkmmk6YhFj2QNGopQ1FdyjwkTApkSyeJ12CKMfWP/9mfUEcJWRqTlzlv\njo+ZZQllBVVVCmEa4HlN0lzsafNC2FpqSajPBQ9dpUJCokKWJMQmXKMoYn7xn/4OXdOwHx5R1xJl\nLVFWOZqmINUFumaBVJMVmYjp3ezGfz2lTIBiynsM63/OSS+KijjwBelNk1ElmTQvCNYBfU9D722h\naQofvPeWEGRVFZ5rkqQhwTpjvZxxq3H/PgXxmna7jWM1aDY9fH9JVRQs5wscxwJNQoo15ssZ77x7\nSLuqN1CcSrAjFFUEDxUZeZ4SJSFRErJcLnn7/WckaYSs2Lx8+ZJeryfyryWJLEnume5BENLtCu54\nsymAI4ZhsF4Hm+9Tx7YFv9z3fRRVEjnYiwS31eblly8Y9jv0um0U1yEMQ/KqBknBDwIqSubLGQ2v\nQ5TEKIrCyl8hyzL7u7tIKHjNJovlnPFsimMZ94eGNCnIE2g5bQzDpC4rLNNhe3ubpb/k8aOHjCyL\nOE5Yr9d0u11a3Q4np6958uQRg0Gf2/GYtFwTrhKSLOWDD9/F9xekScR8LoJGPv/VF3QHQ3Tboawq\nyljEPWuawXJ+Q7fdYTZfohoGaSy62zAM78WOmmGgaKKTvfO4z2YzvvXBB7w+OSFOI1qdNmm4YrVc\n0nBchv0B0gazenh4iFSDaZoMBkOur6/o9TuAQlVLaJKAgJm2Spwm9LsDRrdTyrLk8vqKZrOJRI2m\nyeiqhCJp3N5csrOzxWQ2p4GEaXvcTsZIio6qGmSRhKJYlLlOmqZkWcBqJSaM15dXJEnCkydP7tdN\nv8nrt6KAK3WFqWiUmoLm6jx99xn/5t/8HyxCn+9/+BGWCv7sDJUF/8Xvf8LJm2uUSiLPIvqtLjdT\nAW9BqvD9kGbL5k//4Kf8V//0Z7gNjyRPGU1umY1uSUMXz3HY6rU4/vpLkjhCK0sMXSVcLzn/+guW\n8zmv/NesxtdE83O+evkNfpiye3BIpz2kDGK2u33a/+QnPHz0iPVqTpElqErFdDrl6uqS5XrFW++8\nzV/8n39JsPap65QiXvHoaA9LF8lQhlozHl9CXdHr9FFlhW6nye98b58stWk2GqzXl3z/+7/D8etX\nDIfbKLrGy5cvubkdU5cVWVkQJSJzWNFUWp0Ox+cXtIZ9Pvzw21RVQZSkxGmGaW+yp70mmqGjHWr0\n2h2++uob3nv7Pb78/EviLGU9X+CaNi9fvMCybc7HU/qDXRaLlGD2kk7LwzJlsiRkZ3sfw7JRFAEn\naDQanJ2dMx5NeXVyys7uPjI1rmXyve99j267gabK7G4Pkeqaqi5wbAUqB99f89nnnxNFNe9/+Alh\nkPH++9/DMCwURaHh+pyeXJIkOY2G8KbmVQ2KzMpfU9e14JUvFmiGjqkb2LYQn6yigN2jI8azOa7T\nwNikW6V5dt+R2baNbdv30ZV3cZkgvLKwAdPkFRnZZjS3YhKIcdhsfI2qGjx8+jauess6FXSr8ega\nU9M2mfUSiqmQZQVFmaObBhVgGAL5aNsukiL80YosoWk6WVYgywqGpqCqCkjixlcUmelyyfP/9AuK\nNIG6BOpNSMk/2GyLTmTTXd/tXYU/W6Ku5Q2gRfxbZAlZ1ilrUHSDMkt58eWXfPLwn1GjECchCgqS\nKsJQJEmi2oSd3HXc9gYEcyeivOOkZ1l27xm3bUFNu7OZWZaF5bgiIczQWS7XbG8P2d7uMh6PaHoN\nNE1jFfhQFlw9PycMfY6OHtJwTfrd5qarF3a1LIlot9soQFZk9Dp9bq5ukSQFy/QY3c7o9QZ8+umn\nDIdbG590G3RxEDg7E3akdlsgO03TZG9vjzRP6XUFZ73f77Ozs0MURRvrlhDujUYj+v2+CFyKxbg1\nCAIm09Gmu66BgqrOKIqM29s5ntcAxNqj3+ugffge45sbrq6uODzcJ0kCGq5LVlbc3NzgOA77e4dE\nUcTV1bUgrKVib36n8nYch7osxHte1XRafWzTQZEtymJGo9WiqiomsymaYbBzsEs361HLEu+8+4Fg\njRsms9mE2WzCo0eHdLpNVFVGV2XKPKbRdHl3/x1WvuiidcNj0LeJ05Tt7V28VpPJdAaKjK6ZmBs2\nfqvTJAx9XM/eBBPl99fmYrHg4cOHmKYAnsQbxbau65yenvLzn/8c3TSRVYXpdErTse6nPu+89y5h\nGLJarUV8cRAQpwkVNQ8fP+Ly8pKiKO5JhrKq4s9WSBIkSXKPxPU8h1qu6fe7SIqMrEAQBLjeDjvb\ne2i6harqqKrMbnnA3s4e33zzGkURUaKddo/z80v6/TaTyYTj41Pee+8drq5EEbcsiwcf/+FvVjt/\nG0RsZ5//zZ87roFhSpiWxvGbN7SbDpYucTjo89MffgdLztkfttDVkt/78Q+Y3VwhKzUnZ0tOL28Z\n9JvMpgESYNs1f/pH/4Sry3M+++Wn/M//8l/y8sUXlFXF7e2Y7Z1d6jzBMWSW8znffPMVo+trWrZD\n22tQ5Sn7ewcEwZIojmg0u5heg5M35xS5eNjdjMYkRcnF5QWWZWKYJhIlN1c3hGGIHwSomsabs1M0\nQ+PD957Qarl0Wg3yPEZSRJiErqr4qzXffPWKbqfL7c01YVzw//z13/Ho0QNm02v+8A9+ymQy4cuv\nXmCaBjv7e1ycnbO9I5J4jo/PsHSTv/0PP0dVNAzb4slbb7Nah5xfXpCX+eZibjEajzAtg/lihes2\nKIoKTbc4Ob/gm+MTsrzganTL2cUVhuGyWPuUtUQcxrzz1qN7pa/jaOwfHNBudalKmC8WpGnBxcUl\nl9fXzBdLXNeh3WpQbMIeHhzu4ZgqvU6TJAp58eUX2JbJp5/+HVVZkJUFcZyhqga3tzMU1cDQHUa3\nE4Ig4vZWYAtdx8W0Teq6wrLte/761tYW89kcVdWI44SiLNg/OiQrhI4CRSXLSwzTIq8qkjQDSUaR\npXtbzZ0V6tdfd91AUYgHYRLF2I5DnsYYhoOfKtiWgVoFKKrBzuMnjC9vsByPeOUTpiG6ogr+eF1h\nmgaSJPbpmqEL76ztcHV1g2HaWK0himagSClpFCCrKhUVpm0hU7OMdFL7GXWZ8OVnf0MaRtRViWwI\n8DA11PVmTF4Llfnbbz3DMDWo4ez8gtl8AbK2Qa+q4s9dOpgsbyxmCpVUQ1XT67XpHX0XJIlu9QWa\nIotxey1iQKuqQvk1kAtwrzSHv9893hWVuw68ruv7gJW6qsjyfJMTnmG7HvPZjK5nEEcxrVaD6+sb\nfH+N59m0mh6PHz+k7bnYpkYSr9nf2UVGwrFEV5nGAdPJDYZhkmUpSCrNZovh1jY7+/ukSYK6mcJ0\nu13m8/nmOlDY3t5iZ2eXKAqRZAhCH9PU8BptxuMJURSj6wYgEccJlu1QlSVxEtLptkGqyfMMTVfR\nDY2yLKiqfIOQFTn2mqZSU2LbBlGU3E8oasQBbTjsMZ9NsB0dqRa/2ziJaTfbIg9BUYmTgFarhec1\n6PX6uE6D7Z0twXPPM6QaGl4Dakl4k2sJ126gqhphELG9s4Xvr1F1jXa7RZalGLqBLCucnJywv79H\nHMV0u10OD/Z5/eqY1WJJq9ni7PwNjuvx4sULxpMx8/mS29GC1XLFcrXi8uqS/mBIGKckcY6kSCwX\niw0sqACJDeFN5NRblsX+/j6PHz/GdV2m0ykPHz6kKApubm7odoX99eDgANtxiMKQXreHRE2v18My\ndEajW5IkpdPpEkUR/X6fi6srJFmmrCoM08R0XGpJZtDvMZpM6A8GZHmO43p4jSbdXg9JEQlm09mC\n8WiCphk0Gy0c2yWvKoJAkPSSOMGyTOaLBZ1uD8OwOD4+QdP0zfusoGk6jVaDLEtZr9ecnJwgyzLf\n/t0/+MfvA9fsEscDWZUJYp9kOmfyzYo4DAmlijIcYmsyqmHSaXgYEmSFD1VJVYguwI98TFdFqWWq\nKuNyfM3f/uIXHJ9c8ezp+7z99tscPTogjkMkRcJruASLOf5sginDai1CJfyy4ovnz/ndH/wUyXBQ\nZY8gKQgVm8uwJpIjHncHvLo65p2Wy/nJCeF6xmDQY71cbWIsEx48ekCRJ7Q8i8PDQ8oyJd+c7Czb\nJq9yWp0e68USGQnXskmCEEWG7e0Bw14DmQpVV/jq9SlFVuI12/wv/+p/o9vt8sMf/pBGo8X//q//\nFabhMr6d0G52WC99upaNv1zhNNsocxXTdvn5f/w7kiRje3vIeDqhP9xmGfrkWcFqFbLwA5I05ezy\ngqjMMRQbfRPIkkYR88klirTDH/2Xf0JdJpRZhO00mExnlGWN7/ss/VjAKxoun3znY+bzOU3X4w9+\n9hPOz89xjZo4mPHy7Jhms41tmCyXaw6OHmBZBrZj0u50mC8jNNOj399iMlvR6TaZTqdsbfVJkpT1\neoHTcEjTGNNsU5cVTqPB6Oaa0fWIJ2+9RRTH1IrM18evsWwHzbJZrQN00yDLC7K6FDvZDQ+85br3\nAitVVe99s3eK6TtKlqZpaLJGUVUURYWi2kAhDnGSTW9/FzCZLhc4dkvgPB2POPCF+KgWimBD1dBt\nFVlWkDQVyerQ2mmQrEfYd1xz/t5mpesaUiWAPapqbO6cmt3dXULLIctirq+vkCQZSa6QUaCq7oMx\nHFsotVVTiHckSdo05BJIilDAyxJ1VVBSCjFZXaFoEmUNh0cHiPQkGUmWN/GiErIqvj/R0Wj34/O7\nYn0nIrr7nDs1uizLgge+AZWEYYgqS6yDENu2UZUaSTUIFYnxeMz+7jZxEqFoEg3d5enTJ1xdvqEq\nUkpVBSqeP/8V4/GY4WCXOE6EertMOTg44PL6mjjNsJwGqmmx8AMsW6fRbnFwcCgOaNnmPTYNJEQX\n/vnnnwFiglFVJYv5jF23gSwj/OOBjyQJRsR4vBSdb51SVTm6bmJZzga2IqEoAnTjee69H7iscgzD\nQFEkkmSNpiu0O02yIscwdMbj8WaKINHr9XAcj6+/foW2KVR5nmOYGsOBiyRJ+L5PnpXMF1MURcZ1\nHS4vrwnjiHazzXQ6xXaavPzqM15++YKjowOm4wndXhtHN7k8O6fValPnBet0gefZLJdLsrTEdZrM\npzFNb4s09ZFVjWany3q9RlYVDN2i1WpzM1owno7Z2xlg2TZLf82TJ8+YzhYbTrlGmpfYpoVpmvfX\nS7fbvwcCzWYC2NJqtTarB429vZ3796IsSzRFodfriWS6aSQsv6r4mKJo98CdyWTCo8cPydKc6XyB\nZTrYtlhlTWYLDMsmSlKQFWpJZjKbi2mQ7lIUKqpio8g5nfb2Jka2JK+ETuHmZoTjWMKvX1R4qk6e\nxQyHAyxbQKBGtxPh+c5A1x10Xafb7d6TCH+T129FAZ+v5qzWExzXFMpG04ZY4uqbM3K1ps4TbNNi\nMNgiyzKmkwluowVywXAY8uXpFXldougGlKCo8N6z9zC1Fk+eTOh2tnj06BGj8TXrcE1RFcxin8nV\nFablUGYlrUaTf/uXf8Xe3gHd4TY3kyl/9Tc/p5bgZrxCtTwUU+d77z7j4uKM0WJG+dmv2Nkeoqsa\nSRTjNpo0PZed7SHL1YxOc8AHbz3m/OyUg8NDBv1Dxrc3jG6uaXc7JGFMnotd2N7eAUWRYeUJtqmz\nNWjRbFjEcZO/+Mu/Ynt7SFWk9PrbtDtNjk/foOo63eGA5599xeHeIb1umySJ0GwT03MoqXFaDYqq\n5Ec/+hGr1Yr9/X28lcNiseBg/4hPP/0VJ28uiZMMWaqpypyn+w94+uQdJuMxslyRZTY/+PgDsmxN\nVVUs5wHtVoO6Fg/rOPHJ85RWt0mr5WEYBq6tszV4TFWU+Osp45tzhp23WcQRVVUwn095970PCNKY\no6MDanQRahIGIAlaUS1NURSNIFjS67Xw/fje+7oK1vT7Q9I4pNNqoGoqZsNFBlzXodfvs4wCgjgi\nzQsRztHwqGuJlR9gu+JG0jZWu7oWh5C7UI472Ii8iV1VFEWwulUVzdRJyhwkhbwSe1zLMiljGafd\nR0InzQvqwKdSNrtgVSNLI2RFhrrGMHWqsqQE3OY2amMHGxjFC5QNDrOuCvH1NXGbxnFMlSXUquhw\nZVlC0/UNHWwOqoIMUAqKnLQ5CAx6PUzbYL1OsGQZPww3mjXR/tz5UOq6pkIEmgjvrERVFiiKGOmG\n1ILcVkoUVYEkKUAOyPeF+y4A5O4Q9OvTC9M076cbdV1vkr6Eul9RFOpSfCxNUyQqjM3IfWfngGbT\nw2t51Mi8OT1lPL5luZxT2BaGbREEa95+932Wy7XIj14H5GVNr9/mZjSjRqXdbbK9u8Pl1RVbW9vo\nukZpmtzcCNLfoN/HlmxOTk/Z6vexbXtDrVPY39/nb//25zx98ogiS8jTmCQRmonxrfAWG4ZBnkb0\nB10RTBKs6PV6DIcDLi8vqeuaXq8PiJAZVVWFX7lliSjKToeizFBlhbjM761KvU5bsNqzivHogk67\nx9dffy2COpKYIIrx0oyO6SBJKYvFgjgJ2d/fI0ximp0mV1c3pEWO57W4HY3xw5APv/Ux7XaTk/Nj\n9h8eMZlP8TyPJCu4GU0YbPU2Su6KTreP57rUlUSj0cF0VG5vb1FVh6LM+PCD97i6GdPpDbHdDt//\nzifEic9yuSDNK4qqJE0zdvb2CNY+siSmRFVZ0+p0RFRoHOE4HmEQsAojWht63mQ2I/RXG5iMSPfq\n9XobTHAJVUGRl1gdizSKKYqKIJih68Z9kp0mK1SqILbd2d10Q70H21zfjmm1WgRRQoUACQVRhNto\nUNeg6gZ+KFYhSRAz82f4vnCshGHIzs4OYRgSBAGOZSArIEn1ZjKj0+t3uB2Lr+G67sZrHvzGtfO3\nooAXuUSSp4BMo9UhyRJyqaa3vUMlwfnJKe+885TZYkwQRGhSSVZJrPyIyWxEHOdYbgNZlVktl3z/\n29/i5NOviIsCU6qQq4Cry68Zj8ecX13S29pm0PSoZI2LqxHj6YwPP/6YH//0J8xmCy5uL/nq+Ir3\nP/yAMFjzve9tbSAuEtvDPr2GyoPdLl9++hmGrFMWEMc5mqEznY1R1YqmZ2FbOuOra3YHHYrYZzUt\nyROfYDFjfHPJg0ePUBSNvKg5fPCA45NXbHV2uRwtMA1I4gVbgx5X17e8Pj5muNXnWx98QKvZYjKf\nUIYBkgIf/+B32dnaQZIgyxOm8wnz9Yrl2me5XBLHIT/98e+RRiGz6Zjx+BZdlnj94gXhas16NmN3\n/wDT1Hn3yUOeHO2gKArTZsxwu4us6KSZyfnFBUngs5jPScOIqt/CMHWOto64uLhE14R4hzoniUI0\nScL1bFazgAeH+9xcT+h0+xw9aBKnKaqloZFyNb7il5+ekWUpDx48oKwhL1Wur8dcXV1Rljm93oA8\nq/HsBq+Oz4S9JMioChHL53o268WSZtNDUmTmywVhURClKbplY1ouURRhaBqNhoeq6/ddtiLBOoju\nu21keTPiK4njmHQDIZEUhbKuIc9J85TV2qdWQ0BDN3QMo4FhOVSVhKLIxHFAURaiY5URqTxSSZGL\nBLZKUrHaO6je9v29EPv+vS1OUWVkRGecxjFpLlToiro5uUs1aV5wdnFOlkRIqkyZZ1BVKIq8GV/X\nDPo96rK47yrjSNxrIOhrUi1U5xUbMTqiwNaILty2LWzLIKpraglARZKKX2Ofy/+AiW6aJlmW3SND\n76Iz77rwO6RqFEVCoxBFuK7LOvBRdUOI2vKSJF9j2y5hGLKcT9g92Ofm5gbTNGm0O6RZjCRVSLKG\n67VwvSbNVp/Vyufw6CG2bVNJMJ/PgYo6iknTGImKOAqx9DamaYq1jOtuUrwMWp7HZDpCN23eef9d\nptMpURTy4OiAPI1ptToYukKRg6pAc5OIl+c5jVZzQysT3XZZCrDS3bV1p/q/U64PBkNGo1u63S6K\nXKNVQrB1fTNitVoTB8FGaKmS5zUoKreTKVu7eywWi80Ew8QybdI8R9E0Hj0VEb+6qpBVJXme8/jx\nY+IowfEamLZFt9ej2e1TVSXtdA26itVsotu2oA4qMpbZINJzHEc4B3RdJw4DdMvGa7ZYByGGZTKf\nC5DN7vZQ6GBsC99fiBWhrqNo8n0iWVnUm/zzfEOoq1mvA8Iwxm2KGOTQj4TVSzM4fHDE6enp3+tg\nGg1UVbiP2u0mL774kgcPj8T6bD4Xv+O6JstyPK+B53kbz7WHrpvM53NcR0B2prOQvb09sqKg2+3j\nOA7L5RLDsIizXMBnsoiSAtPSMC0N318ynU85PDri5PQ1pm6QSyqypJFnFc1WA1WXSfOcxXpFp9nC\naXhkZS50NLLCfDkTUa3Fr1k4/3++fit24Me//Pd//sXzX7GzvYWEQlmGXLw5od1s8ujhAb/7nU+I\nkyWyKeM6Dk3H4OT4nNF8xWQxww8SoqAQHWjsky4W/PB77yBpElGRM1suUQEdiTKJ+et/+5fCWrTy\nSYucw4dHmJbBs2dPCKI1pqHR7Q2wbAM2iEDLMZnOr+m3OiwWM3RN4aP336fbcnny7AEHD7bZ3enS\n7bh4jkGn7aLpEtdXl9zc3nJ2dUVelEiqxt7BIa3+FjejGf/p755jmA5pFVPUFUeP3kVSND788G06\nbZdWo0Ot6njNNpPxDE3VWa1XTBcTeoMeO70hV9djzs/POTs7Y7jVI44CXNPEbjfQTZVPvvsJ12fn\nFHlGWSRYukap5JxdniOpEo1Oh06/TbPr8f6H7xJWEleTNarR4ef/8Uuef36CIsuE4YKGbeFYMr2+\nyNBNk4Krq1sO9g/Eg1ySsQ0DQ1GRagj9EElSkSSFKPNRDRXJNJjOA27GC/Jcpd3a4ujJA95+511G\nowUX5zekaYFlWpimxvbOHqpmUFegaiqNpotp6UwXY0Bia2cPJBnLc5gt1mQVpDXImoGqW8R5gaqL\nWFhNVdBMjTIvNwEH4ibqdgUH2rZt5I0/+c4veqegrqqKMAyJg4wgCnEtkzBKUXSHVqtBGs2w7DaG\naRGtb/DnM7IgJi5zyHOkqkbZqLIdz8UZPkbzBvfwFIBgfEpj+ABJkrD1iqrKyTOBA7VsB02V8IsG\nqXGEquRcvfmKNAhQZImiEElkUi3sYIKyVvHRt95HVSQc1+bFV99wcXGDotlIsiBo1Zu9t4yEdLdD\nR7rrt/Fcm3fePsKv+tSSQit/hSKVqKqGYZj/ILTkjrxWluX9+P9uZF8UxX2nrmna/X4cELhVQwj2\nDEMn8NeYtsObkzc8OdpjZ3efKErZHu7jOk3CIEXWNBTNBBSqSubi8hbfT1mtQtIs59XxaxbLFb3+\nkKqsMRSdOFjh6iYdr0WWJSRRhGFpqKaKbmpMJxM0VaE7EICjO3qZaRgsF3PWqzlRENHyGrSbLfzV\nip2tLbqdHhISq8WKs4sbojCh398SkKGbEXGc4nlNzs5O8TeCS8u6A7kI9bskielFHMfMF2uaXpPB\nYIuqrCiriul0hqoZtNt9kqREUg2Wq4hWs0uSpCBBmqWs/RW2bYnzIhpZWqDIAlpye3OLrGzcEGWK\nrkq0mx6OZUJVUucFtqXTchzSMkKSxfs3Gt2yXq8wLYvnX3zBaj0T3edqQbfjEgUL/MWUyzcnrNZj\nFLkkTSLWfkQYBoRhIiJDw5CDg32SNCKJYxRFopagqmqyNGPQH2LbDpqiosgKN1e3BP4a6kogj/MK\nyxKRxf5qRaPpsJrPKStYLtfIsoamm5R5ca872Ds8IIiWTOZz8lxcc4ap4UdrqqKgrmqiOIVaYrlY\nUpbikGnoFjc3I25uRpycvKHIC7755hV+4DPo9wWASZbJshxdM3FdjziOcbwGYRChqhor3+fq8poo\njtna3hHTkThmOp0yHA7ZffTBP/4deKff4Q//+E948+YEJU9xNBtNtpjOZzRaTcGUtXUcyyYMY+bR\nGtcxqWdzLN2i47XxlRB/GaAqgKYgVTKvX7/C6zY5ffWaC2Q++vYnuE2XDz55j/efPUHRdC6urmm0\nOsRpxnw5I84SppM5umWSZKnYZz/c49mzZ6zXR3SbLR4c7uA5Lp9/+ksOj3bodbp88+or8jLjyZNH\nGLbJ1c0lWpbRbm+zPXxAHIVEUcDt7ZRma8DZ2SW/fP6CWoKzi0tM2+bs7ILb2zU/+9nP8MOQspYZ\nzxf8/u/9hOvrSx4+OuAHP/gBo9HN/WjtzcU527vbHBwcUpcVURKxtaPx5s0Jew+foUoqwSKkzAuq\nqsC0XWRFIVkX7O0fYNgOu3sHFJXMF796zhfPXxEmBbPJjCDYcHsXazrdPqaxg6qkrFcZ7WaLvZ1d\nFE1jMhFc8tl0wXe/+13W8wWO4xAFIZpmcPrmDY1Gg92dIxb+guubEUlcs3/wlCjOma8K4pvp/em4\n2RTIxjw3mE585rM1g8EWlm4QZzG6bnJxeYllOXS6XZZrn4KaQqqRbY80KzFNAzSNNApRKKk2e1fN\nMAiCNbKi3WdU34U8mKZ4YOu6uskzt8iLgjTNybKMbMP5pkxxbJNaVlC0TfZ1WUGZkEUr8Fo0PIeb\nGso8QiklskqAJcoqR5dVnEaHymwBEqgFFCp1VWI61qZLq8nihFwGCgH+KIoUGVCNO4aySBEzLItw\nlSABJfct9P3fiiJQqDUKo9sxUFNJwhMuyYIAV1c1VV1RVxWKLB6qFCArCkgSeVqBLNKrkAWB7U4X\ncLd20HX9Puv7rvusquq+O78Dt9wJBZvNJsC96j9NC7KypC7YdO4wGAwoy5KLUzH2Xq9D5vM56SbX\nOYx8wiCmP+jy8OFj6rpkthkF7+3v0vIanJy9wbZFvkBdVOiaxuXlJZJUk5UFR0cHLFcrPM+j0RBK\ncElRkGXh33716jXvvPVko7zWeM3gmeAAACAASURBVPXqFbpu8vjxY5I0xw8CJFkmTFL2D4/IK01M\nIdKK25trqqpG1wQqt6pqiqLk9vYMXdfvbYvC8VAwGAwIw4CtLYFQjiIRZeo4DpIksVwEjG5nbA13\naToOba/Dajlne6fPZHrLarWg3x9SpDmLyRRZM4Rv2uyRxj5p7FOYKq5p4DTEVCqJU168eMGzZ0+F\nFTARgSTzyZTFYiF206qE49hkmQjvWCwjZGmBLkMSpQRrn1ajQZHEXN1cc3BwQF0rxFlNo9lmZ2+L\nKE4xbYMkjVgul/irNf5yRW/YE3a6do/ZdCoAKZ7Dzc0Ny9WcPM/JopCPP/6Y49MTkkQcFLv9AZPJ\niLyEoqhotbtomoFhmsiKQlqkSHVFGKVEcc54NMX3I+azJY5r8dZbTxmNJkwnc2pZIU0yWq0Wk+mY\nLBN0OVmRUFQZ0zLY299FkiR2dnaEAA+Z4+Nj8rykyEsOjh6gaDrXt7cYmk6Rl5iGhWVl2JbNzc0N\ntVRRVQW2bd+z9H+T129FB/6//k//7Z/P53Ouzs+ZjseQpbz48gUg8T/89/8jYZgQJzGdTo/ZdEWR\nJaRRwtrPOL++wfZaDLf7nJ1dk6UVDUtjp2vy5K2nNDstGl6Dn/z4Jwz6PZIo5pNPvoOKQpym9AcD\nxhMxEun2ejiWQ7ffo9vt8eOf/Jijo0Nc1934N9cCjTgai7ShtY+hG5y+OWO1DsTDVdGoapm9/SPS\nNCcMfebLOZ1OF1XTUQyd+XLFYh3x2efPyYuS2WxNWVU8efoEyzZQJPGcHAyGyLLKoD9g6a/58Fsf\nsVjOuby6Zr1aMRqPmc+WDAcips71XObzKbPZhO3tLTqdNsv5AqoSqarZGm7R8FrEcYqiaHR7fQzT\n4vrmmuOTE6qiJAwD0jjlcO+ANA75we98j/fee4f+oIUfrIjCQKR3IWpElpWom4u13W6jygpX19eM\nRyOKvKCoCvb3d1j7S2yvRZpLTKc+jtcmSXLevDlF0VQm17e4jQaKopOmGd1en5ubEVEU02l3RIau\noVPXFbqu8fStZzx+/JSvj48xPIeiQuyGZRXh8RQ+5yzLMEwdwzA3AsMMSRYpapoqWMX2RhRzp0L3\n/UBk0JcVURBTlCVZKqxORV6hqSqe7WBYpijK6LiOhanGJHFOezCgThfMx2MWyxVRklCmGTVQSRVH\n736XHA1Zs6GuMEyJspCEFZEMzekKC1gRUEsSmipgEzUSiiwT0CPVdtGUjHA9oS5z8lTYX5CAqkaq\nQVJkVKXm/XffRaaikmo+++w5RV5ToyAhi6zzu1CTu1QygBrRkcsSDdfm6ZMjgqpLLWl0qmMoxbTi\nTpiWpuk/QKbekdeAe2X6nWjnDvySpiKD/e6lyEIUF4YhZZ6TFQWGrrHVaSApFUEY8uLFl2R5zNZW\njzBa0R902N4eMhz2cRybi8tzut0uzWaT9XrNfLmgLEssy2Yxm/L40RGXl5d8/fVX5FnGZDzm1fEx\nT589Iwyjv7czZRkg3WecrxYrJuNbut0OBwcHVFVFp9MmSeL7oq+bJnleIKsyjabLaDoiiHxMU8SF\n1rDxhDd58uQJuq6zXq/Z3t7eZJKHG4b4anOwFAcIRVHJ84woigjCgCzNaDQ8Xr58TpKEQEUShixn\nM3rtLoaqE0UpZV3i+ws0TSYvEkJ/hWUbtFstwjCgLmsUSUZTFZbzOadv3uD7KyGyzXOyLN/YGDOa\nXgvTNPG8hiCYVQW6phGEPq7jUiMRRDG7B0eiUFsOw60dvEaTJI3J8gxV13A8m4vzM+I4Ynd3i6OH\nh4RRgCRB022TRDFJHBP4Pv56jambdFodTEvf4H8lgiAQ71GeM53NsV0Px/aoJJnReMJ0NicrCvwg\n4OHjR/ztz3+Oruv4vk+73WU6mXH04JAoigX4qMgYbu0wX8yxHXsjghOBJVEU3TtcROyqtgEYlZim\nyPz2PLEnz7Mcy7SQNmFCq9Uaz2sQRTFbO2ItaRoWaSqwtqqq8va3f/SPP0701fN/9+fDwYAHh0fs\nb23z7//d/y28r5KG53V4cPSITruH57ZYLVYMBx2mkxEnpzdMV0uWfkBVV0ynPq5j4hkm//zP/gjL\nswh8H89xyNOMq4srdE0jDkPm8yWnJ6ccHBxwc3PF+fkFzWaLr7/5GklR2N3bRdN0FEXGccRp6cGD\nB9xcnNJrNUnDgDJPoMgZ9Dp02y08t4FhOpyenLP2E87OLgkin1KqeH1yQZxl7O4dsFgH2G6D18en\nvPXuu7zz7gd4zSYfffRtVE1CV1U8z6OuajRVZ7pc8M3r14BEnhWs1yuajRayrOA6bZI44Ohon+Vq\nRp7GhKHYN1GDqsgc7O0xnUwBmTjKaDXazBYReSmT5bBYrNFUg267y872Lq5hUlcp3U4TTYP+oEOj\n5bJeLzB1nd2dbUzLIIwiWq02jWabxXKJIss0mg0CP8BzXUbjEdfXl2RlgSRL/M3/+ws0vYVutGh4\nHbI84eBon52dLR4/fsL11S1hGHNzO+b2dkRVVezvHxKHEZqqIysy3X4bTdeQJIUkS4nrkrKWQJWR\nFY0ozdF0kwoFy9I3u0dFMK83IdhlVVBXdzGeMvpmnKvrArwQBhF5WRGFYk9Z5PmGMqbgOA6e62Ho\nKiVi11ZLJoau8mC/w8XpBYal46gV0/GI29sJaZFRpRWyBFvPPkZ1uqJ4A0hgGGK/GayXLOdTGt1t\nFAVUUsqNDawsCyzbQZYkAgZkmpiGLKdXhOsVWZJSFJvgkvsxeI2mwgfvvY0sS0RJwvPnXwEqkiqE\ncpIki89HZFVTV/epYYqsoCgyrZbHW0+PWBQ9akmhnX+Bqcv3IrVoA7ypa5G29OsMdOA+4OQOq3r3\n/9/tie/24qqisN4Qw6qiwHJccWC0VbyGjduw6fZatNoNGk2PZtvDa9jUdUGSRkxmE8IopK5EOtrr\n1695/vw5nU5nM9qv8VcLLMui1WrRbrXE19r8HK7b5PWrY2zLYXtnm2JDUev3+8iSRKvVotNuYxgG\njYaHpukMh8N7MVua5QR+QFkVpGlMb9DG81wcz6Xd7VDkxT25Lc9zJpMJnuf9g1WNYQhb2nQqyIlB\n4KPrGlVZUJUVNRWGIfaxr159xWIxpdFsUpQ5Ddcj9EPkSmbt+7gtlyRdYFs6nWYDRYam57J/sEMY\nhewfPiTwfQxDoyxyPNeh1e6KJLRawtCEqLjltdA0HVVRiaOYupLY3hqSZSlZXhBECWlWUNYylu0x\n3NrFsl2SNCfNM6TNtbFaryirXLDqi5yiyJnP5ywWC9rtFlVWY+g649GYfq9Ht9PFMk3iKGL3YJf5\nJjRmuVyKrO9ccBRqYLkOcRwX23EZT0YMBkMsx8R2RHjTq+NX7Oztocoqo9sxsqRQlmJStLOzQ5yI\nCVm/30fX1Q0GWFzHuq7T6/UIw3Bz4KxRFOn+wGqaFo1Gm9lsQbhek6cFhm6wXAVEYUINJHHKaHx7\nf1/cKeyfvP/9f/wFfHz2yz+3LYfx7ZjRaMRHH38Lw2xw9OAxlSzRHQzp9Lu4XoNup0sSr8iyCMNs\ngqaz9FP2jx5wdT1lazjAUGr+8GffZbFY0NzYEN6cnVGWBYv1Et0wSLOU2WKO4zlopo5lWpu4u4HI\nt1773NzeEEUhw0GPF19+QZ6lhL7PyekJZ2cXpFHCcrUW/KqqZjReMl+u8MOEz58/J0pi8qJkMpnz\n0Ucf0x/0sVyHPK84PHyA4zUoipyqLPnggw9oddo0vQZpmlHkObPFEstxkVQJ23ZYLBe8ePElq8WS\n7e1tsjjBc20MS8IyNVRFI8/g0cO3oFSoVQXbsjg7vyAMY2RZdAGvX51wcXnDzc2ITrtDEIb0e33a\njRbXF1d02h6tlocil6xWc/I8JstTDEOn2+qAVLJaLGi3Wqi6yssXL1ktlzx58kQ8zFWdhw+f0t/a\nZuVH9Hp93nv/fTx3SBhWOJZHt90iyUJURWG5WHN6ekqW5WIHqhnEQUi/28O1XJoNj9M3b4jjiO6g\nQyXJBFHM7XiOrIndXprl6IaBoipkSY5pGiRJhKLIyIpEmmQUhYCMKJvAiLquMbRfU6GHIWvfJyty\nkiQRntsowTA1TNPAdiw0TUeTJYoyo6gqdN0gLwVjfXenS+QvOT8748GDPcos4fbymsUyIEtzdt7+\nGK+7/Z9d/RJUGVWtEPlC7GS5LeoyRd7YkapKWMHiLEeqINX3SdUhmpwyvj4ljVPKPCWNIyRZ2rDQ\nRca45xq8885TFFni1ckJ19djNFUccCSZjQpddN/1ZuwuIXzbVDWSXDMcdNke9ljWWyBJDOovyNLk\nHtqibmxcUKNpqrC8SfLfHwQUZeN9FmI3TdNIkuQevAHCEx+FAbppYpsmpqlSI6PI0HFNNF3F0AyK\nImdra4iuiQAUebNbHwwGSLKwq1ELTUOr1aLT7eJ6Hrqm4bk2UbCmLEuGwyFQYdomO3v7NNstxuMR\nYRzRaDbwHAdTN1FUldV8IbovQwNkbq5GNBttwjBiNBqjKDJBENBptYTQscg2DPqMwPdxbZfAD0iS\n5F5HUVXVfecO4pAzny8pihJN07FMlWA9p+U1oCpxHRt/vUSVJdIso6xKbMdkb28XTRZs+Den51xf\n3aBqmlDxGzKGXtNyhV+6zDJGtyOurq9pND3+P+7erEeSNDvTe2xf3HzfIjz2JTOrsrK6upZeWF1k\ndw8pUiABaQRdDaQ/IAH6D/1XBGg0BEYgRoSGIEESHJLT02RPdVVW7nvG6h7hu7m77ZsuPs+o5jVv\n2BN3iYzI9HAz8/Odc973eZ8+e0WaJYR+QJ5lRHFKkhYMJ3Nm8xVVp8JWb4esyAmDkMHgSgCFDANJ\nVqjXm8iyQqPRZDKZU63WqNcbLJYrgnWM6+Ba6FQ8z0dVZAaDK05Pz5AkxIh87uJ5Pt1ul1G/z2w6\nZm93G11TyMnI8oSt7U3OLs6FayNJqZTLaKqKaZr4YcTcXbCzvUu328XzVnzwwQdrvoCGrEikWcJ0\nPKNeb7C9sydy2/2Avd19gijG8wPynLXdN+P6eihsiO0us7lIj5tOp+i6ShwLiiBZgW2ZDK+u6bQ7\nfPX1fcrlCovlirwo0A1rLWqeUq1W8Tyx3i3ygtVySavdYqu3Q2f3vd/8Hbi3Cvjlwy/RFZ1up4lZ\nqXH4fpn7Xz2mvb3B4eEhnuciawVqDs+fP+VHX/wQ7c0VD16f8vbkmkZ7mzzPiZMVtbJQlrZaLdzV\nEqda4fb7twnDEM8P0U0LWdVY+Ss6nTa5BGmekSP8huPxEk0x0Zwyr9+8Yj4eibEKEq2dY06HLovE\nxShVUCSJ+89PUBQFW9f5V7/3uzx4cJ9SRYBGnFKdj+59D6eisFy6zPszVFXcELePjwkCH8hJopBg\n5XN9fc3JmzdIcoEXrNAuL+n1erw5OUWWVN6/c5v6Ou5w6+gYVY1xV3O++eYbqpU2gZ9z8mrE/t4x\nSiXi+YtnFIUIul/4Hu50Tr1e596OQLaqekqtZiITEfopjqOSEZNlOb3tNnv6Fk+fv2DT7hJHEe58\nTOT7ZHkCeYqs6kxnYzRNo9Fo8G//7b9DlnSGoykHB0d8/vnnPHv2DN/PaTW3KJUyfH/J11+9plyx\nePNyTlYodDbaJFnMeDxlf2cPQ9lAQcGdjOn2urQaNQoZvCBiGURIsk650SLwPQxNxyrZa3tUgaoo\nFGlApeQgyeCH4U1noygai8VcKJTznDhKyPKUHHBdgaHMckFMK4qMWsVGURSccokihyRPyZBQ1YI8\nBdIEcokMk189uOS9vS7z8ZTzV6/YPdzn8dcPefn6iq2j96m0tyDPKJsKy/jb+z9JZVHHswzTWu+3\nCyH40k2NIpVAASVn7b8WNrI8z7BKNsFqRW5Y+JpHngk8qyzJIjHNcYStS5YYDkfi90JaJ5FlN90y\na/uY6NsLyAWCVS6ELU9SFMhlpCKFXHTMpmmuDz/ZjZ7gW+BNcgNo+XWRG3Djr3+nRH/nH1dVFT8M\nkU1TIHENC9ddsjKhbJfwFh5xEjK6GlIUOaWSRZEW2HYFXbeh8Nnc2BKxsetOvl6vUy6XuRoMCFYF\nFdtA0xSRJWALK9dsPuLW+3eZzCccHh+w1esxHY3pdraYz13B9Y9j0Q1rGvOZB8VkHZEZUqlUsG2b\n8XiMWbIpmSUmkxGHt455+fwfWLm+cFEkGeOx4HE3Gg3m8zndbpc8FwKtME4xdIssSVHIsQ2VaDXD\ndZeM3jEKdIP9gyMmc5dWow1ZTi4XAiwlwc7tW2gCGICUREynU05fnWDbDmQFaZ6z9OaU7DJn/XM+\n++QTZpMpllXCVi0ePnpGp7fNweExqixU5KNRgKYqbGz0iKJIXJOlz87ODo8fPqHT7RLFAYPBAMO2\nKJVEkFOSJLjuksHgGl3XRQ55ktButxkNZzQaTeI4pl6vkibQatcFQW0hIlRTP+DN2zecX5xQrTWp\nOGJakUZiRROEMZ12m73dAwLfF1Mm32M8Hokud7UiS8tsbPTEJKFSZbUSiYOyppMkObbt4Lou9VqN\nN6/fiolIKq7HxcUFeZGt40QddEXl2dsTut0u47nLYjGn1mzw5Zdf4q2T3N6enbKz3WO2GKMbFuWq\nw3Q6pdOuM+xf0tnocjYZcXFxwfnZJR988a//WbXzX0QHfvn8Vz8bDq7pdDo0Wg2SPCMMAvr9c5rN\nCppaUK/anL19RcWyqFVtNNvmy6/vM1v4nJ9P1paWlCIP6bZqfPrhMfOFS63WoEB0AWmeYZkCTDCf\nzbh7932KPEXXNVYrH2Pt5YyjBLtU5uWLlyiycmP3GI3GBGnBp598Rhwn+J5Pr7eFYZoc37qFU3Yw\nTJ3JbMidO7f50Y9+hGNX8FYBfjRjuXQZjcaoqka5XGU2m1MUBZWyxdvXJwwGQ+I4YTDoo+k6jXYL\n3TSp1uo0m01a7SbdTpskTphPXCaTCWWnjlOp0els8uDBE2bzGXEc4ocLChmm0xmOU6bZatLpdNjs\nbVKtlVGkFMcu4ftL0iQiCQPSOKTdqGOXS1QqNnka8fDRQyaTGQc7h6wWK0b9Ae12i6vBgB/84HN+\ndf8+F+d9Op0uSVLw4uVbRqM5v/r6MTM3oLOxjaqZ2HaZk9NLgihANxQ0TSbPCxynxmK+otpwcEpl\nRsMxdkkU15cvX/DJx99lMLqivbFBXoCXJuimRYZCkubUK1VAoshzVFmmyHIqjo28PpSlaYqmqiRp\niqaJkARNU1FVnSgKiZOEZG1pedctCkqaRsmyME0Dy9IJw0DscPOCPE/WhVTYvKoVHT8qSDNY+hk1\nNSUKFnR2ejz85VfMQ4Xjjz9HkmWaekiwmpOppW8fgHWs53h4hWaYmHaJPPVQ5JyiSMlSkQyW5gWO\nWWIhdYjUNmrhM51eQZ6RpQnLhQtZgiKtqamSTE7KreNDFFnhy199Q5LkqKop7HDrQv9OA18U36rC\npfW+XZYL9na3KJerrOigElKNn9ysG0Th5ibn+12RznOhUn83RgdubFS/Pj7XdR1N09Z58gVJnBFF\nIWmSUEgy89kUNY9Iopzh1TVbW1tkaUKRF2RpTtkpo6oacZKurXwigGY6nWKoQoD3zTff0O12KVkW\ng8tTsYKqV9nb3yJMYkpOmSzPME0L2zaJopB6tS4ohZqO5wkVdqVS4bLfp1ptCG1EKhKr2p0WURTe\n7DjDMGK18nj86Am1SpXhaEJRFLx88YqNzS6TyYT9/T1Wq9XaSiXGscuVT61aJwgCnj7+Bk1CKN0X\nS/pXA1arFdVaE88PkQqJOIpZLBZUyjV0u8RoPkdSVRqNCpPhNWQJaSFzNRzT7vYI4oRWp8fW7h6O\nU8cql5EKiZ2d3TXGt0wQJRRItNod0iQkiSNh0VwuGQyusKwS4/GEkl3i8vKS4fAKP/RotVoYho4s\nAeTU6jWCOMb3Az76zne5urqm0WhimRbtVhvP8ynZJbZ6WyzcJbbtMJ9c02q1BMo0iSlXKiyXy3V+\n9oxatSJEjUW+RraalJwKlmmSZQnTyZTVcsloNCIKBchnuVixWK4oMlBVfZ1AlhFHCbP5nLJTJgxC\nHEdQ/uZzF1XVWCyWYn1qmsymU2zTIsvyG1tks1phuVqymM/I8pzj4yNevn6JIhfs7PYYDodAThgG\n1KplHNuk3Wgwnc/odrqYlkm73ebg7vd+8zvwcBlh6gbj0RWKCo8ePeL92wd8dPcQU9NR8gSCBXVT\noWooNCqbvLgaoSAThR67O02QA2xDIi+AvKC3s82TR0+pVqucnZ1RqlgUWcrbszMs3WQ+mdNq1DFU\njcV8iVRIvH72ilK5zMb2NlGYoerCoxpFAdP5kov+NS/f/iPDDz/k9tExZU2jWi5z/8tfMuz36Wy0\nSdOYMIhx3QWDwWB9Iyg0ahWmU2EdqNfa1OsNVMXg5z//OZZh4nke0/mMzV6Xw8MDkCXaG13m7oLp\nfMnu7hae53F6fsaX//gVG+0eG51NXjzvs324ycyd4WcZyDndrSrj4TUdqcZnn36X1dJDUxWckkUU\neFz1+2iKjiynDM5FfJ63dJGRIMtR85wiDBmO+my2Onzn7haPHjxlOLziux99RBxlzOYe46nLYhHx\n6vU505mHJD3g4vwKp9LkD//wf6LRblNvdri+vuLN6SWNRovxeMjMdcnTlMPDQwb9a3TLIApiZpM5\nkiJjmBapmtLZ3uZqNsOPY/QwolB0FDkjzQoqTpnFysMLvRshVZ6KjjTNM1RNJQnjb3Oo3zG3UUjT\nhCTxCcMISSpuRsHvOkrbtqlW6kjrQlO8SylbW6DCuEBVIcsEfaooMiw9Jo5tvAAUSUIPPNzJjPHE\nZfv2J8iKwuDtM7Y+PGLieihyiyz/p0mCYZxSFZ+AmIYJWYCsqaiyRJDEyJqFJBVI8rsQhIxqtcZi\nMsGdL9b+b0FgK4qCQgbfD1BVHXc+x/cjhOUqpygk4V57FwNerANMZDHmkyRJwGBkER+bZAUoIBfx\nTZHW1nx3TdNuinlRiASzdyCXdG21eRffqGlCoZ0kyc2/8W5HLl4f64NShm6abG70UCIB73m9nBEl\nIbPpFMPQ11Ysk2bZIS1yVE1jNpvdYFEVJGYLl1azKa5tHKGqKrv7OyRJwmKxIIsTkiTDNG2iJCKL\nExRFItETfD+kVm3ieR7ttqCEWZaNqsqcnb3hk08+wQ9WnJ2doaoycZyiKB6FpDCdL+hubrGzs4NV\nGpAkCfVmjaIoODo6YjyeMplMbgRSRVFQcWyR9FWuYJfKzFcB3zz+e44PbpHmEs9fvEZSLW7deY/5\nfCGmGpKgBC7CGKdURtcMkrhAs2xSWUIzdW5/+DGHh0eMx2Nqtca6i3bpdTdvfPCz2YLAX/LBvffW\nhEEIvIgwTLBTcb0sy2K2cJFVjflqiWEZfPa97xGEHt1ul9VKhLQ0Gi0WiwWu64r3yPe5dfuYrd42\n/cEl9UaNKA4xTfPGXnhxccHR/hZ+GCGrBoZu4JSqvHj5hp/+5HdZrXzGkxE7u/uswmt6O7vr6Q6s\nlh7q+hDY6XTIMzFVsq0ys+mCilOmUqnx+vVLxOFCiAg9L6AohHj1/v2vODw8FDCeJMGyDELf5+Tk\nhMPDQ1zXZToVvPrlcskwWGLYGo1OjyiMCcIl3VaZSr1G4i+Q0oBaqY5HjmPqTEYj4lCkvwmino2i\n/fNJbP8iOvB0cv4zbzFnvphwfHQLKS+4tbeFmkds1BvomkK0muOOxmiSzOn5GU9PLhgOxMjr7PyM\nP/j9n/DmzSm6qqFLCr/9259SrVbRdYPJZEIcB0LNG6Zosk5RSFiWQaPeoNvu8M39hwyHY148f8nJ\nWZ+VHyDJBt2NDWr1JmdnFximzcHRLZI05eKyjztzaXe7NOpNDg+PODt/iyxLLBar9f8Z8Xt/8FNU\nQwjThCCmw3LpMZsuWa18ptMZ3jKhVK6wsdFms9emVnOYjMdkac7V1Zgkz3CXLsvVEsuySZOMKMpp\nNpp4/opfPbjPcDLGchx2d/fRDI3d/T32troUmehAp5Mp/YtzHn1zn0rFQVMUGvUaURyhqNDrdpiN\nr9ncaJKnBdeDPtPJiKvBkAKd//hnf4E7m5PmoCgqcZwyHM8J4pTJbEUUp+zt7HP7vQ/4yU9/n08/\n+y2mswWKolCuOIRBwJuTE7Z3tslyse9buj6aaVCpVTl7+wZFUqk2mgynE/wgYv/wABSZQpLJJZkw\nTJBVBbtkI0liGJwjkRcFtmVhmIYoKoVEFKcUa4+3JEkoqtjL5lnByluxXC7X+9PkxpcsyzKGYaCt\nQSlpnBLFEZqmkySxKPjIaxpZgiSpRGFMVkTEWYzke+SaQyrpZNNTWhtd/uEX37B773vIikJJFvGV\nGTGOnrH0EmT11x7iNR/dMC2kLCAjRVEl0VHLEnkhkccRnrZLrDTQWJJlEZEfEHoeUeCvwxXXIBZJ\nokhjDg/2GY9GnF30ARVV0cgQSWHvaG15kVO8CzMpCkRGmaBJvf/eLVSzhE8LLXdpSGc376uw03Bj\neRLddPrtL/TutRTFTZ41cENgy/OcWq2G67pYprmOJxX/rxfEZElCq1xi72CXRq1GksQUFOzsbtPu\ntImigCRNsEs2r09O0A2DheuKa1gUJFmKhEycxGRpQqdVYzwRNjN3PkNR9fU+1SbPCkxd6GGCMCTL\ncryVj+8HgikuSdi2zfn5G45uHZGlMcPhkMVigWkKdXGt2uDBsye8/94H1OsNHj16TLVeRVZkZBlM\n0xI+7+mUzc0NKhUBG7Esi9VixfVgiOf59AeXuMsV7c4WR7fucnx8CMi4S5/FakW12mA2nVCt18jy\nnChJaTbamIZJkWfs7e6SKSqSouLUatjVKnEOC98nkyQkWUHJYTyZ4Hk+lmURBD62pVPkCXG4tsZ5\nHrZjUa5UiWKhx+ht9rAdm+M7R8iKxGavhywJxb5hGGI9gsJiuWRra5vhcEiWZTiORRgGtNstge0t\nhGhP1VTBX1cNppM5rWYH6QHVtAAAIABJREFUw7Txg4hut4cfxrS7HfEa0pgkTTg5PeXg4Jg0FeK+\ns/MzUWArVTTdxLRssrQgz8RaZz5b0Gq1mE7HtDttXFdcM0WRWS6XVCqVG0ufZVmsViJX4x2AxzAM\nhsMR8/kcTdMYji5ZrpYgF3Q22qyWrqAWSjmL8RRdkemfX1CtlInDkLOzU2RZIssLGs0GjUaD4XjI\n/nv/vA78X0QB7z/5y5/N3CEb3Sa1momqhEwnQ2RN5fyiz+DyjGF/TBilnFy9oVSr8+EHnzD1xanm\n3ntHnJ+94vd/9ye8fPyc944O2OlVefHmNbJh8PzVCV8+eM7z02uuZj7ngwlvzi9ZpYBS4vGLU84H\nUx49f4OsV9jYOCbNdUBhPFvw53/+V1xdTXn58oTTs1dUK2KU02o0cV2Xx08ekxU5ge+TJCLIvt1q\n0Go2+Zu//nu+/OUDCjIePXzBN1+/pFHdYjwasr3TwLJU2p0KrU4FlILJdEKYBEiqghsG3P3Oh9z/\n+gXzWcjr130Gg+kaaFKQE3F0uMUnH93l7p1DPvnwfabDC1RSqo5J6Mcsli6KIlGrValXq9RqVRbz\nKZVKjSBYoSBRLlWQVQWr3ODP/uIvuRjM+P/+/D9h2E00s0wUp8iGQqPTxqy0sSsN7nzwEdVGB02z\n+MH3P+eLL35Kp7OLYToMrof8yf/7J+zsbXI5OGXlLWm16ximQxQlDEcjgZKNQpxyGU0xODraY2tn\nl0qjQV6AXaswnM5YJRG5rJIDtaYQ3AkbR0FRIKI+191ckiRkqaCcsd69qqqKpuqsPA/f94SfOxZ+\nT01TblLGGo3GDZebXFjFFFW5IWepqiY6HkWotnXdXMd9FUiKjiJpyIYFeUGGSntzgz/9f/49itOi\nu3uMKheYpoyfxmSSQppLGLIQfhWFBJKMbZcwTJFfLBFjmypZkqNrJl7gkeYKciERaHvEah0lGTOZ\nz1CKgpU7I/R9RKJYjiTLIk+8EOrvi8srfD8AZHJZRpJUijxHkr+dAghrYH7zJ1mS0BSZ994Tz0Ok\ntDAll3L8Vry/heCfx3GILCvC45xFSJJEksQgZEhYhk4ch2sbWYFhqOR5CuSYpi4iLg2bPE+J0oxC\nKgS4Dpluu02zbBGsfID1zlzlb//273nx7DmmYfHgyZP1eNdC13Qsy2KxcJkvXFRFWJ3KtoVuqAS+\nT61WE3vSNGY2m6JpOhSIVdpigTufY5vm2gYasL+/R6lkC71KLmFZOsHK56uvvkLTNNI0Y3dnH0U3\nkVQhNrx77x5v3p5gWBbD0YgsTcRqIBWZ5NVq5SaUI4oiFt4KQ7NotTusPI9Ko8nLVyc45TqVWg27\nUiWXFO68f5f9gyP8MOT49m2yAjIUprM5zWaLwI9wnCovXp6QZjJSYTG6dnn76gwplxlcDnCsEpEf\n0T/vEycZq5UvsMGKxOPHDzF0hZKlU2k0yPKC/cNbRHFGvdHE0A3OL87Z2dslTTKKPMe2Swyvr+j3\n+yiKwmw2Q1U0Do4O8f1AhDstl4D4HLq8vBSJgeuV1mQyIgwDUhT619fCz61bjCczJvMZqqZzdnaG\n6y6gkBiNJ+iaOCi4CxfPW2GaJpubmwz6fVrNBvP5lNXKJS9CVE3BKVtIkli5vH17IlY2EuvXoRHH\nMZ7noWkar1+/XnvRq7TaHV48e8mDbx7y/NkLojClXm9SqTUwLIer4RBD06lXqizmC66GI07PLzk5\nu+RHv/MTvvr6IbKq07++ptHtcHxrH11X0RTwF1N2737+m1/A7//iT36WFRn7e7vMZhN2d7aZL1x0\nw8Ap1fH9AFlVSbOMRqvF3/ztf8Yp1dGA2XSGpupomk23vYlpGkymI2aLkAKDLFMJc5mf/5f/SuCF\n2IbIg46ynPP+mD/9j3/BxeU1kqyh6QbVRoNOu4nvubjumM++9xlbOz2urgb83h/8PsvFjG6nI164\nLGGXHR4+ecyLVy/RTBu74rC10yNKIi4uLrDsGtV6m4pTJfAT5lOPo4M7fPzxh1xfv2F87dLvX/Pq\n1SnnF1f0tnZpNLrEKUxnHm9PLxheTehfXrF/sEcYrLh37w5ffP59jo72qFVNTk9OKJXE7wWQJDFx\nnGCZDvPZjHLZIksz4jjC85fIioJRMrAsmzt336PdqfP46VNKZYMPvvMh16Mpk9mUjc0ey1XA4fFt\nUHRenV7yk5/+AY1Wh7//+S9wFyt2d49QNYO//Ku/YdC/4vT0lGarRRwn7OzsMJ1MKDtlXjx/hSwr\nRFFIe00xWi6W6LpOpVLl4moAskIYx/hRjCSp5EWOqijYJQd1DQGRJOkGHGKVSgJekuYUsoysKCia\n2HcrqkpaFERJwtJb3ais8zyjbNvCYqVpa1SoEKq5rivG5Gtf9DtW97tu8d2oPs0LgjDAME2SNF3j\nQ8UoPU99cslmOnW5PHnJ/gefYFgV5DSEIkbRxH1MUaDKMqpUkCUrTEMiyxVAgsxHkcKbxK4kTlB0\nHdm00GQJXz0gVqpo+RQvCIkDj8uzMyjE96ep2B+vRwUsVz6BH5AXrKM2FWRZoSh+rYCvbWc3X3mO\nlIOqyRwd7CPpZSK5jpENKSUXIv5U0UizBGQNWdFI0gwynTDK0TQbWTFRFYswyjGtEpZVIc1ykrRA\nN2x0o0ReKJhWmaLIWS2XZBRkqRDXCSuTzkajQpamFAViEmaYBH5Ad7OLpguewd7+PvO58FDXajU2\nNzbIsoyNzQ2q1Sqqrgp8qm0SxsI9sru7Rbe7KTjt66jd2XSKaZo0m0267S6L5VKQxFYrbMtic2OD\n2Vz4hXVDxyk5NNotoW9otwhCD8/z0DX1RlQ1m4xoNGqUy2VKJZvNzQ10XWe1WmKWSgwGQ8IgYaO3\nSckpc3FxyXc++g47O1v0ej3qjTq1Wm2thBbxlY1GHUDw+TWdzc1NXr9+g6LKvH1zQqlUYrVc0tvY\n4sXzp+iaRppkpEnC9tY2l2cXbG1tkmYxeZ6RpBF7e3vCAWBZ2KbFYrnEKjmMxhOSRFiuvJWHYRii\ncPo+pmExvL6iu7FJEEa0m20s06ZebzJ3FwyHQ2zbZjabUavVKAoIgvAmaOT6+ppyuYLrLmi1OyID\nXNexTJPB9QBd1zk5OUFSBLffdZc06k08zxf3eVFQSDm+F6CqKo1GDV1XqNerSHJGvVHBMgxMyyLL\nhDd8c3OD8WTCyltRKZe5uLhgc3PzhmdQLpeF4Nlb0W638P0VjlNie3uHO3dukyQxrU6LWrXG4cER\n+weHLNwFG5s9Do6OaTa79HpblJwK+wf7tDsdPv74Y7rtDnESEkURo+EYy7DYfu/7v/k78FyCWr3O\n1w++oVmrM564HBzexvM84jCh2mjjzuaQych6hbvf+ZTB1SVf/PAL6rUeCy/k8nJAnsbcPtogDCY8\ne37Cb33WQVVN9o96/PZPfowSJ+xs97gej3j4/C1+FrC5s8vBzi5R4HPv7l00XUJRAvb22qRpHVmK\nyNIA01Lpdpvs7RxwdnpJq9XixatfYRgGt+/cFTYZXSFPEy6urilbJjsH++zsHfOP//hfKdlbfPRR\ni/ns79jea/Hs5ROePn3G/vb7SEpBvVWjVqtRLTc4P71gNpsx95ZMpnOajQpbW/t8cHcPb1ml3Swx\nn14xm0wJAw/bqjAYXNPtbhLHKY1Gh0ajgalrTKdDVu6CMAzZ3t3HDyMOb+0RRQHuPODv//M/Mh2P\naHc3QFOI0gzdlvnf/4//jSjMGY/m3Lpzl9LVlOPbnzKdztZ5w10Gg2tevHrNeDQhzXL6/TPq9TqL\nxQLfD7kajLi8GLNyY/a2byGpGc1mnTiM6HU7Artqi/CKertLkCQsZoubUZbjODcYU9M0ST3vxoqU\n5gVRFN8Ip4o8F3vMOMYPA5F1jWBO66pKVuSCdKbrWLZJHCWUTIuCXPDOgwDbNH+t0OfM5/Mbi1kc\nx8LrG0WoqkaaJqRpevN3hpEQBCEZKZICSZqjWVUq9Q0ALEslieU15ETwwpNUhDBomgZ5jCknRHFK\nnsUohnETcSoj40cRaVFgmiWydYCKqsH19TXnr54J1bEsk2YpiqIKkpqiUqwnDiJ4RABuZP7p/hvW\nxfuf2MgUpAKRlewHVByRgKaREkfghyt8f8XS9zi/uGI6n4txZqzdXLN3uFRFkVBNeR00kd4chHRd\np1Qq4TgOjWYJimx9EIjI45jO5i6vX71iUDXp1Jt0Ol1+8P3Pefr0CXt7B6RpTLVaAVkcvnq9nrCm\nIXF2eo5lWYI5n2d43hLNMEACu1SmI8soikat2aCQJTRNo16vU69WhR0+S1m4M6pOSSj1FVkIuIZD\nDMsU6VKyxGZ3A1XVmUynSFLB1J3y3u1jwiCmXLKoODaqnFOv1wXTPopZrlwMQyNKRbRku90lihKW\nSw/TyDk+Pubqqi8EtXHIbBZxevoWSZK4vBTK9eVyiePYhKHPZHqFbdtomoznLcmLmE63JUSuFYNG\ns4KmGWv/8ZLT07douoyqCW3CdDrlw8MPxH1QFDiWLVT6jsPDbx6xu3dAIaWAcDI4TolMBMhzdnZO\nt9vh2bMXbGxskOQFF5d96r7AhbbbbbIs4+joiErF4fWrM4Igol5uULYqJE6KO1mwvbGzLvAFb968\noVxyCP2AjY0OzWadl69f0W63aTbaQrleqxHHAUHooesqsgzdbpvnz5+K7tk26fcvSdKI46M7KGmK\nJMHmZpez80s6nQ6vXr1itVgKYWSWsVgsmM/nlEqlG/eCYRjs7u6uFfUus9mMh48e8qHyEbVajSAI\nMAyDAhUkhfsPHqEg8cUXX5AWOQ8fPqTX62FZBl99/SX7+/ukabr+LEn+2bXzX0QHnrrPfta/7JPF\nAkbgL5ZcnJ6xs7vL29cvuH//AVFUsHNwm1dvLylVaxzdPqBQVbrb23hBQMmxWS1mSEWKY9t8ePeI\ndqOEacpopoppaFQqDrV6i+liQW97i/Fsyk9+8mOOD/ZxHItarUSlUsJxbMbDIUt3RW9rh3/4xS9Z\nLkMq5SY7u110XeXwcJ9bt45wyiUePXqA561IE59et0OjWsE0hF8YKcT3pmgWoBSoBlhlnctBnyQW\nqtwwT5kuJvjBks2NDnkes7vVxSmZfPGjz9jZ7HLn1j7Vkkmv08b3XHRFRy4K8kKm1WqRZiI9yzRF\nLu1sPsedTRgPh5yfnnJ8dMzbt2+RVR3Lcvj5f/maP/vTv+HiYsjrV5dMFz7f/fhTvvfDL6iWW8iy\nRb3epSgULi/7yKrYjRqGxptXb3j+7JnYeykaZ6en/OAH36fdbqFpqkAuRiHdbodqtYxt2WxsdAk8\nl/l0hjufo2oG/cEV1UaTiTvHqlRIUyEoEX5kCduyyYuCvBCdhvGOs10UgBCnWVZJeLGTlCAIWK4E\nSCPLMtK1RznNMtHJWxaGrqPKCpquk2bfFmHLsm6oW+8Y3e8KUKlUWo9KRScehOENdlVVVWzTJEtT\nDF0nlyWKQuR2i4lMAwC9CIjTCHldIPX12E5RFbI8+7U9sdBKvCveSZKgKhqqoZPJBaos4Sm3SOQS\nUnzNwgvQVQWZgsj3UWThyc7zDFlRKLIURdW/7ciRkJVv1eDvvqR15X4XbCLL3BCnut0umtMmUyqs\nrh5w+uxLHj55yvMXb3j87CVXwznLZUCORJSEBFFIFEe4S5cki5jMRkRJgGMbbG1tsL2zwZ33jrl7\n9zbvvX+LO3eOsCyL3Z1tmq025YpDs17HdirEQYBBxt27dxj0hRI8jmOhKi9ZqKqCoqo4JUdkVq+t\nSYqi4DgOr169YLFYUK1WkGWZerMu0gPDiDyL0U0DTTVukqSMdTa4aVpcXfUplUqEcUjFqVDkIrFO\n1XShNo8CFFVF0wQ2NopCsiJfj3eFsG82m2Hb1noykiHLEp63YLlc0mq2MEwLQzfQNIPZbMb18Jqy\nU+bqesB8PuXp0yeoqpiWOE6JNE2Yzab0eptri9eITqeFqkhkWUK73WJ3Z5tWq04Sh1xenlCQ02hU\nSLKEWs2hXHFQNInQ90AG27ZoNAR1bDad0G61WK1WXFwMOLvos7nZo16rkaWZOLgAFLCzvc1oNEKW\nFfwgII5ivJXHylvRbrdvAlvEymLMdDqh1RIBKnt7O6xWS96/e4ev73/F3r4okmHgM51MkGWBE97c\n2MTzfSrVMrpuoOkqp29PKZWEluDk5C1HR4dcXpyzv79Hv9/HdV2SOKIoYDgcE8cReZ4xGU+QZAVd\n19A1ncOjQ9pt4SAwTAPbstdCRWsdC5tRLjtEYch0OkXTNM7Ozuj1ejTbLWRFJgjE+qHZahFGIXfv\n3iXPEkzLIM9SCgqazQYvXjwhSWLq9QZxHDOfL9jY3KKzf+83f4Tef/KffjYcDHDMEuVSCQWJjU6b\ny/MT4iSmUmtRSBqSbvH05Tm2UwYpJfBzXHfG1fUlUZpQyDaTWY5daWM5KqgqSZYyd+fMJnMs3SaO\nUq4vr9na2eS9929TLpnEkUenU2e5mIOUsVgumc1c5nOPIIqZTZcMhxO8lUe7ZdKolwn8BUG0wrI0\nSqbGZ598hEHO3tYmJdMgjyPc+YT+xSmhv2QV+kiFzsqLWXkh47HHaBQymV2QS1BvVGh3apimhK2r\nbG20ONzroasSxvqmJStQChld0SmVLC4vz+l0u9RqVSDhxfMnJGlIGK7Isgg5z5iMxjSbTba3t3nx\n8qVAnyoak/GEx48fo2kqf/BHf4S7WPJv/tf/hX5/yOBixPB6wsbGFpZlY9sWr9++YjabYJoGL189\nR5Il7ty5LcAEqyWj6ysGVwM0TUXTZZyyScnRGY36VGs2S2+MnKukSUqS5JilEgs/QLEMWhubRFGE\nH/iYhoEkSdSqVRbLJUkck+c5tiUyd23bRtX0NahBCMCSJLkhgOVFsS7gKbqmU+QZlmlg6oYQ2Gia\nKFQS6yCC+KY4vyvQ7zzNIDzL7whiQmVdIJEhUaCpCrIEWZYSRSEly6KQJNLMQFY17HLt5h6XiwxF\nTsmzlJIpGAF5kaGqCkkSoyjyem9coCgiIME0RVBIGASMJxMuB+e8fvkCuf59FKuGvzzFsmssZmPm\nk8lNAZakAlkW+/o8zZBkhSITFDpk6aZDl2Tp5rAivZOzSYUAExW52PvLEp7vo5U2MMsdXvzqz3j2\n4B+YuS5ZAapqoek2iiqiGdPcRzcUTFNjZ3uTg/1tjm8f8ju/8yO+973vsrPTY3dvSwTSmBp2yVwz\n3oU80PM9ojAS7xGsR+hl0iRBU7UbncJiIQqj8OcLvrm2Fsm9SwAThy8LTVPWOfAhsiSRJSm+72MZ\n4vNhNpvfeLlbrSaaqvH1119TqZSpVivohsHV4BpZVuj3+0iKLEhgccLCXTKbzdaUrgh/5dFstm7W\nMcIDL9NqtbEsm1evXlGpVshzodYnB3fuctUfoEgStmkzHg05Oz/DNI314aMqQCejkcgGX+dgR1HE\n1taWUPqTUyk7qAromkzJNsmzFNM2MAyV7d0eeZ5imBq2bWAYGnEsVNvvpiCmKX5mNhVedd2w2ehu\nsFp5NJpNEZm5XHF9fUWn00WSJFRZYbVcYZkW2+uCvrHRRZblG7b8cDhcWwhlqlUbXVeYzyeYpsJ8\nOsa0dbIsxrRK3Do6gkI8W4Hv0WzUMS2T2XRGpVxmNp3S7bSQJYnz83P2D/aw7RIX52frg7YhOPAz\nl42NDdptse68d++eEK3JEmmcsloumIyG4pnNMy77Ay4uzlE1lclkTLlSplwuc319TRSGNJtNkiTh\n/fffx3VdLvrntNsdmrU6w9GIKI5xnBLT8ZBapYxTspEliXq1wmh4xdVgQLVSYTKdiUzxNCMIQg7v\n/dZvfgF//vVf/+zi8grLqeKHMVEUoWsGJ6dnhEmBopYYuS4L30dSHU5OLzg/O2N0NWW1XHF9fU21\n2WCyKvjkR3/EH/7P/4Z//x/+lKBQqDU3ePbkOVeXfbIkIQlDlCzHadZ4/PQBX/zohyRJyPX1gJ3d\nHVRDR1Z1tvd2qTaaIMusPI/f+fEXXA/7PHn0KzY3N/ADj/2dHS7PzzF0DUvTIMsZDcXDt72zQxzn\n9C8mGGqNycxHooSmVbnsj7k4vyLNcn7393+Mael8/PGHOI6OrkpUnRJkGbIk4S1dkjSmbFm0Gk0W\n7hzLNEnW48PRZMTKW7KYzZlNJ5Dn+MsV3XYb2zLY29/HsWyq9Sq3bx2zu7NFnER8/wef0myX+OjT\ne/x3//1PaXXbeKsIXdOp1Rv4QcirV284O7/EtCyePHnEaDRiPp/S6XT58MN7Qm0sFdgloQDf29vl\nvffvcOfOLbIsod6osVwu0A2VctlBVXTscpXd/QPBsK9UcWpVFoGHKomgCMdxSNOU1WqFogp+tiTL\nN2NZaf0BrGgqgvDk/RriEPIsQddU0cnKKpVymZJdwrFt8rWt6R1C9V2n9i7DWoxcBUBFjMrVG2+4\naZo396uqQJIK2pssS0RhgKrIGIaOH0YU2MShj6JqNz+ToWBqosNwbEtEHmYJcRytc78EbQ0KwdOW\nJSE6KyQKqcA0DDRNRpUk1O5vI2klsviacqXJ0p2zmE9J41T4cPMciZxCyimyAlkW75X4WnPPZenb\nLnwdniIyyNbfqShIuchsti2b1tZ76KUG169/QRZco+kKaZaKmMs4peyU2N/v8eln3+E79z7kow/u\ncevwkMODA7qtFnESiOcv/lZomKUpeZYRhwI0o8oC7KIqCnEQIMsKk9EIoiXNZoM8T6nX68zdCdPp\nmNl0SpamOCWHi/NzTk9PkICSbVOpVoWoMU+p12soqgIUNOp1ZpMp7VYD27KQJZlqrYYX+ERhhLda\nMegPqNfr1GpV0jxhPB5zeTmg3e6yWLgYls1yuWS5XBFF0Q0+3rYdfD9gMpnQ7XZv+Nuj4YQkTsnz\ngigO2NzsiU7+hgiYocgSpmFQq9WI40RwGIqC7e1tcdUkiVardaPX0HWdwWAgCq2qomkqpmnQaNZY\nLlyurgZUyhU0Q4j6kjjBWy2YTWccHh6K151DpVJBMwwWy+V6iqQRrGNeozjGKZfpbW9xPbxmPBqi\n6wrj4UBMDgOfTrcN5JQrDovlktVqyeHxwboDFofAd5OscrlMlIT4ngeF6Ob7l5e02i3a7TbT8Zzp\ndEzZKWFbJttbPSaTMWkS45QdoRlYx71ej66xbQtV0cmynM2NHqqq8/XX95lNZhwc7GPoJovFEsM0\nmExEB33VH5AkMf3+JZ1OG0WWmM9nAuSViwO1IAmyPkC59C8vSNOMN2/e0O/3xVpNFgFGsiRRqdYE\neluWKfKMJAqIwhCynKXrcnp6iqppjMdjGs0GzWbrJtTm6MP/BkRscjb/2ZNnr3j++oTFKkaSNQpF\n5ax/hbv0GFxPOOtfMHZdFNXm9Zu3PP36CW7q8sMffsGjJ4/RyxZYNu9953s02h3OTk7QLIvjW4ek\ngYdlKjgVh63dHvV6lVzS2NhoUa2VicMA0zKZzubUmy0kSWM0dfn5L/4rF+d9VE0RnObFHKdkkKYZ\nvc0tViuPVr1JFqcEfsDMDdg/uEUhK/SHI9xlRJqUuR75BH7M2ckV0/kCSYbjW3scHG+ws9OjWjLI\nigCZmI12HdPQiMPohirU7XSEJ3ujSaViUak59PsDFM2g4pSJwxhDM/jOhx8R+xGmblIulcnSiL3d\nPRRFZXd3k/H0mqvrAV9//StevnzNeHrJ3Q/v8PjJI0YTlzevrvH9mLPzMwzTxrRKPH/xgjDy6PVE\n0d7Z2aFUsklT4UFut9u02222trZQVZkHD75Zj6IldN3k7KxPb2OPstPALpeYuUtBw7MEjCdIEiRV\nRZVyZGQUSSIMAizbFh1knpNlosaUy2XR0SARhDGu695gKUUGtRjZlSs2mqZQdcqUbIskjsjzb5Ge\n7zzKIMbk7yhhSZLcFPN33dM73Oc7n7OqquRJiGkZBH5wQ5hSZQWJXHjxKRH5KzTD+rW7XMBmKpaK\nIsmEUUQugaxAliYoskSSxkRRjCwL0pptl5BlhSCOKNKMsmOy0e2w0D6kkE2S6IparYM7m7Caz7Et\niziKyLNUKNElQFbI13Y6JFmgVmWheqcARVXW48p1/Oi6GhWIbh6gUi7T2L6LZla4ePLXLGZvCaIA\nqSiIwpR779/jhz/8hNu3DylXTMplG7nIKLIUf7kgSyIURUKRocgzZAlkqUCWRIBJnmUYmvDdep4v\n1gxSQRLn2JbJVrOGXTIJQxE/KUswGY8JQx/XdQHBl241mwRhyOXlJYvlEk3TODzcJwwFh1pVFcKV\nB0VBr7eJt1oirw/ocZIwnU2REc4G2ykRRgFpmmDbJVRVJ88LdvZ3ieOM6XSCqqo3QUfNegtVEQEx\nSS7EYpqmoSqiiJtri9xi4ZKmCRRidD2fz0QnLkGz1uT07JzNjR7VeoXpbEZRFMLx0mohSRLL5fIm\nFGY4HCLLMrs7O6iqQrvVxDR0Hjx4wGh0zccff8ygf8VquST0Aza3NnHdBb3uhjjsqZqIkZWFlYqi\nII4iVEWh2+0yHI2RVZkgDNFUMVUJ/SVRFHL71hEUGaZhoMgSURxxddXn6OgAp+wQRgHdTpcwjDB0\nkzzLmUymqJpOrVrHMixGwwmyrKJpBpeXA5JYCMiKQqwjnj17imnoqJqw+umagqrIvH37hrJTIooT\nVFWIJ0fDCYPBNVkcY5om9XqDjQ3BqZ/NFkzGE1rNFkkSMxtPmE5GDPqXUOREcUStUQcKXHfBj3/8\nY2q12o1Pv9NqUxTwx3/8x3z++ef83d/9Hdu7e2z1eqiySm9rCz8IiAKfq4sLKHJsy2Yxd4nCkHq9\nIUTEScpmb5N6vUG91mA+dzm8998AC/3P/sO/+9l0viJH583JOX6S8Xe/+CUffPwJmmnjRQkffvAR\nq4XPztYmP/qt73Pn3gf8D//jv6a3vU291WGrt8vu5iYVu+Dt86+QlmM2yhYfHR1wfLCH41RoNVr0\nOh3GwyEjd4aqyOhwBizyAAAgAElEQVSqzmrlUxQaul7iq68ecnoxIEkyLvt9VE2FDIbDa2zd5M7h\nMaEXUStXadSb3L//AFnRUVQdwyrx9uycrx48QTHLLP0YWS0YT6/Icg/DzHCMhE+/e8j+QZvjw22m\ngyscp+Di7VtIChRJo5A1nrx8jeuv2D84JEkL8sCnZhuQ5lycnlFvNqjWm5z3LyEOMQ2NRw/vU8jw\n6fc/YzgZUauajIZDbMvi//6//k+m4xmjK5fB+ZSjw9sUhc2LF1f8xV/9nFKlSaNRR9FUDo/2MC3j\n/+fuPZ4szbPzvOfz7nqbN21lVlZ1VbWdnp6emZ4ZAIIXAEKhAEBCZCACC/0D2khcaNEKLRlaaqON\nFAopSAEiACkoDEgYQjDD9r68SX+9N583WvzuzelZKrgQRxlRkVUVVXnz5v3ud37nnPd9XmzHpFAQ\njPi9vR10XUNWZMqlMo4j7FeL1YIgFKPJ5XKJ4zisXJ8nT54TxylpBpPxWPzbMARTJ5Rk0anGGZqk\nYMgqmqKiaRrL1QpFVVF1bb2jlUnXARtRFAnLzWJOFAR4qxUZCk5OpCc5jk3OtsiZFo7lICvCpxxF\nIaQZiipG05uCvNl7R1H0E3ASAYKQ0PQfk8Q243NZltEUUYzjJCKKQlRZRpJkgkAkhmWSQxKJcBFV\nM66v8xQVTfIJwhVRFKCq4mvGsZgoiAOGSDuK45haVahyVWQMS0GWE2QkpvrrZJKOv+hSrzcJ3ZA4\nDvF8D285QpVlyGLStRVMUXWx/s5SFFkhXdvWJEUVIBZFQ5YU0kT4wCVZQkYmWxPdivkcld1XUA2b\nwcMfUrZhv7XF/vYWb7x8m2994y6OqZIEPlKcIMUpUgaqKqIYVVXCMo013U2DTELKFEhVZDTSJCUM\nPXzPJ4sSbCeHYzvEsc+ge8E33/omcRjQ7vW5fecOjx4+pNFosFWvk8vZwungiF1lsVjEdixW3orJ\nbEqtJpDBw8GAnJMj54hEqSiKURWJNI1pd9tomo6u2dzY22c2GTGbCAJYpVoliBJcP2I6nSEnKV6Q\nYJkOnhdQrdSpVRt0+138IKBYKa335AaabpCRslgK9Kjj5ChWqkjraYskCZHl1fk5ra0WhWKeLI2R\nFRHjaloWxWJxvV+P1lkB0ZrkmGO1WrG3HqEbhkm302M588jZBY5u3EJXTQbT2doCVkfXbTRVI0ll\n0kzwBVRF+LXTLIYspdft8ujhQ3RVQ9YMJvMlcZywt7dLlsQUiyXSWLhDck6eIAy4uroijCKq1TpR\nlKLIYi0wm81FBrjr0Ww219MumeVixVW7x3S2pNlqMZ5M+er+YzRVcPwtXcdbuezv7XHVaUOS8Ud/\n8sckcUSpWMA2DB4+fEK91iTNMsIwwHNdcrk85WqDXD5PtV4l9EP+/u9/xGg0YrpY8OY33iCJfLZb\nW1imxa3bt8SBTZGZLuciizxn8+L5M3Rd4+riFN8NKFcbFEsVXrp9TCGX5+L8gre+9TYvv3yHJA3x\nQ5/FfMlo0MfQZcrlAmEk+Bqj0YBmo0a9XuP07IKD/X0kZNxVgO953Hj52/9eBVz6upDl/6uP/+t/\n+m+zMAypVGp0ez2cnEUUBSRk1KoNGmsD/mq1JEkShsMRSSZRzDv4vofv+3Q6HV57/RU0TSPnFOj1\nemiqytXVFfoaLhD4PpEfYigaaRZRrTV58vQ5qSSjahqXnS7fevttgjBjMOiRJhGlUpGTkxN2WjtM\np1PaF23eeOMNqrUyq9WcJ0+e0NpuUioUuTxrUygUuHPnDt1BF8syOD99yutvvEqWZWiKiusKRvNk\nNiUMY3Za29dM3ygQWckrb0kQeMRJQKu5xXzmEUQ+xXKB2dRj5S7QVHj44CnuckG1WGC1mPM7v/Nb\nDEd9ZpMx/V6Ps8ulQL06Nqolsbu7S62xTa87RNFkDMNCRoBnqrUGz09OsZ0imZQKsMnashVFAaPB\nkEq1zHLhUSiUUFWVzz77jEajwWg04vLynBtHh6RhQM40yZIUWVUw8kVmboAbRYR+hm7bJGsLlRBq\nrcVhWXJNOnNX/jWtK45jvCC8Rne6rovjONfFVFEUCoXcNY5SkqT1fi9EVcWunHU6leChQxjGZEl8\nXZStdZzoZtcdxaK4i+/nx/axrxf7jchsszdXVR05g3kQEWRl0thnORtTqG7/xLU+HnbpXtynVCph\nGAZeEIioVFUmjmN838eyLHw/vMaTrpYu49mUwWCA5ya885//C6xcBT06w25UMTWJ9//vv+bpxx+h\nKwpxGoGkiGxvS/AMxHPbJIyppJmEoSqEiXiusiKzWMxF956lSIjJRELC7aM9tl/7LRQ9x8lf/pfo\n8VJMLTKBlszWIjxJkrAc+xqKs5libDrVLEuANTRHUq6nF7IioZCIyYxmMZ3P0HQVhYjEW3BjZwvS\nlHyxICYs+byAohiasFHpGsGaSR5EIVEUkCsWePmVVwjDkEcPH4pON82olIvkHYvRoE+jVufJ00cc\nHt6g1+uz1dpjMl6w1Wqwu1dlOOhxcXrGzcNjNMuhPRijl8oE0yW5XE4cFmyBZt7ch0bTCTcObtJu\ndzk8PCSKIi4v2xzuHzCfL4CEIFwB2XWwiW3bzKdzDm7s4648DMtE1U3G4/E1ftYPXBaLBVEUcXx4\nRBxHdLtdKpWKuLesx9SGruOuPMH3rlaYz+frn31Kv99H0zTsdQJasdhAURRc16VYLCLL8rUvut1u\ns7vVolAurQNrZJbzMWEYEgUhiqbT6w5EBkQ+x/vvv88773wfx87xox99wGeffcIv//Ivcnr2lHq9\nzt27d/nqq6+o1Wq0WjuAvKabDcmyjHa7i0JAs1Yn8Hz2DvapNRt89NFHHB0cMhqvePXVV/mjP/lj\nfv3Xf4MHj57gOA6LxYxypYSytkdqhs729hbj8QjXFeyAv/u3f8Xb33wTWcrYbjX45//L/0qtscXx\n7dvMVj6N+haL1Yrnz59BlnDv3h3SOCTTdHZ39+l0ByiqTpQmdLp9JEkhbzh8/OEHeJ6HF4TsH9zg\nu99+k2a1yHt/+9dUq2VxL18t8V2Xq04HSVP53n/0iwwHE956+9t8+umn/No//i9+Esf4//LjP4gO\n/NF7f/Fu4PuQpWi6xmw+p1yrMJvNGPZGBKHPxcU5jx485Pat24RRxMnzM0I/IWcXSZKUJM7o90aU\nijXef+9DHj9+xvGtW1y0OzRbTYHh29uFNRc9iSO++OIBruczHE4Zz5asXI/FYsVwNGY6GbOYTxkO\neqiqxv7+HpKioKuKgKHM55imgabKFPI5avUK+ZxJnATUKkVOXzwjjjzyeUvkTa/j8/r9PlkmYegC\nF9ho1AiCiCgIheJ15TIaDHBXcxzTwjBUnjx8hpMXXO6L83N6nUv6nSvSOKZZryIDOzs72LbFaDQk\nS+HFi+dcXJzzrW+/yVX7lN39LWzH4unjB1xdnDKbzDk82Ocv/vzfiKQx06JQLJGkCBb5uqBNp1Nk\nWWGr2aLb6bBaijHvhx98hJSlNKo1ITTaatGoNWhtbeHYJpquM53PibKM6dITgifNgnWRDgOBzfR9\nb43kjInXnUYGJGlKkib4gY8ia6Rpcl1kbdtEWe+cbdvCsqzrOFCRUS3sGdKaMZ6s1e2kwmOsayqm\nrq9HnqCp6vXuN0tTbNO8/r0iSdf52jISmiJiROV1cMeGMBZFMVIGXgiZbLKcj2l32tQaP5k+ZloW\njiVRrdVQVFWgH9MUVVExTWsNjBHjfM/zCMNQ7PBzNluNLV668zLq9s+uhWljQknCMjRmvQHdixfo\nqkaaxWuBWoyk66SALGtr+pXwsadZShxFJHFIGMcEoY+u6cRRiCRBGiO8t1nKW998Fb2wR4LGjabJ\nzabJy3fvUqvV2Go12T/YZ2e3RaNZp9FoUq/XKZVKAhtcLlMsFikUCtRqdWzbFkI0QxfTrbWYMIlD\nLMtmGQQ4+SKQIWcJUhJQsC00XWEwGK53wJIQRmkKnr9CloUS/ez8VKShWeZ1Strl5eX6UGcwHg7p\nXFygSBLTqSBnmZpGELgMe11M1UCWZHb3dvDdKaZuMJ2MaG21WKxcdNMmzEBORWyq67qcn5/TaNSR\nJImzszMqtSphFOL7IWkKQRDSaDTwVi71ep3pbHRNr9vb20OWFUzTEiruMKJWr+N5Hkiy4FUEAfV6\nnRuHB4xGI6T1YXRDNxPdeYCu61xeXrJyPZycA+vDt2VZQMZwOGRvb49qtcZ8OsN3AyaTBdWKQM4m\nUcx4OESSJbrdrrDVVSpMxlP6/R5BIFYbmqYync2IU0m8p3WdYrFAo7HF5cUVcZzyzTff5t69ewSB\nh64rWLaBoqgittPzsCybwWC49oDnqFQqSJLMdDIgJWM6Eejc+WLB2ek5qqIwGkwYjccc3Djk4eOn\nlCs1PN/l5ZfvIEkZ+3sHXF5esVgugYxOp0Ov12M0GSNnGa7nUylX8P2AxcqlVKnh5IokSHR7PdJM\nJ8s0Lq96nJyd4wYRDx89Q1Z1NN3i4eNnSIrK/v4hz5+/IIoyrFyBOE5pd4eYdoH9/V1enJ6Kg5dh\n0drdxfd9YQ+0bL71rbfx4pTReEyxWEJWFPaO3/jpH6H/7Z/+4bvzxYKl57FYrshkmdl0hmU7qJLC\nF198Sb83pFgs89nnX3J2esWbb77F2dklV1cdTNPh4cMnTCZz3JVPrztgd/eA9lWP2WIhEn+SEFlK\nuLq6EqxsVefJi1M00+bR0xMObhzieT7z2YKc7fCD73+P1XzGztYWEhKabmAaJroq0ahXyDkWq/mE\nQt4hSyPOz18wHncJQo/d/W1Kpfy1HeXi4pI0TlFUDU0TQH3LMInCgEePHiADs9mEyWREpVLEWy2Y\nTMbMZxOGgz6qYuLOx8zHXZQ0pegY3D4+pFlrsLfToF6roqgqCRKLlUenN0DRTA726tTrJerNKu5y\nwbDXYzGZ405nnD19znwyJZMkgiRmsnDx/YQ0lWlfXQqspGmhqTrj8YSzs3Nc12e7tcN7773HSy+9\nRBLGJH5E3s7R7/bJ5wtcXrQpVaoYhRzt/hA/hsCPkVDJFfNIsugq47U9Ko5TrFweRVMF/xvRIadp\nhuf5qKqwfCxXS0DswTVNjNtt275WixuGcW2/imOh8DXWXmoJ4TneHEoEUU1ZK9ZTojgmSdO1y0rC\ntGyiOBFcfXkdtynLREkiRuRIKLK6FiAJu1UUiRzyINXI0NB0i1p9S+wtZ6N1R6qynLZR5RQJCHxf\nWOrWu3kRtCI6X03T2NoSEJLWzjbVcp7trQa6rrHKvwWSTBh0kFUDKQg4e/qM6bALkgggUVSVRIox\nzTxplqFqylpnnmGYOoVCDtPUae3skKYJcSyKeZYI4RuIA4ymKahKxuHeDqs0T6pVqKYvCIMA3RAw\noCiOCIKQKIqvf+YbPvpGb6DrOpPJ5JqNvtEXAKRpjKMbLF2XVJYxdJPFYoa/mFHImdw83MfQLXb3\n9tYHNGHHKldKwlqkaXS7XRwnR5LBZDJlNp0zn81BkpAyifl8wY2DfU6ev2A8HvOd73yXbqfPfDml\nXqvi2A7T8YQ7d+8gZQK0E0cJpu2gOzmCKEa3bMaDOdWKYB1spjS5XI6rqytWK5eDw0PG4zG5XIFq\ntcZwMELVVLI05qp9Thj6qKrKixfPSZKUarVKpyNgJsr6EDccT9aZ4wWGwyGz2Yz5fMHlxRW+53N0\ndJPFYomiaFiWc72+qVbrYsSNtA5oycjbOSbTmYjB1XRUVSNNM3TNJIlFstdkPMbUNCH0UlU63Y6Y\nvsnq+rVKGI+HFAt5VquVuH/ZeaJICEJPT8/Y3d0l8AMuL69QNUHaG0+G5PMOYZCQzxdQVWNtp0sx\nDYtmo4mTy1Ep15jP5ty4sc/VRRvdMDFMm7/4q39LvdEgDmKeP3/OdP16zpZLJEnGtAwUJSMMfVYr\nH5CoVKs8efJYXM9ZymQy5a1vfZvnz8/IMoXecMzRS/fY2T8iQeXk/IwgTHj6/ILx3COVNBrb+2hm\nTqxBFINBf4TvBRzsiuvn6vwCL0mo1ZvcuHmTi6sOqDLvf/Qeo8kII+dwePMmq8Cn3e3R2tohyyTa\n3T6mbVCtVjFMi5zjUNv994sT/Q+igD/48K/fLRZLDIdjceEB7U4PCYVquQJI9Hp9oijh2bMXrFau\nsL8ocOulYwqlPOPRkNffeJ1CMU+91mA8nDCZzrj70h2WywmmrvLB+x+QZRLLlc/7H39OJutMpkJg\n8tZbb9Fut9FUmXq1hKEq7O62yOfz9HsDNE0ln3PI4iWmoVJwnOu0JtddoioKhzf3MUydZrOJrAhv\npKYagjqkmxSKQmG6Wgm7lEzG7eObXF2eY+gqpWKR1WKBKkskUcB0OqberFGwizRrJRQpIgkjIOHo\n6BBFVrm6OodMwvV8ZFXnRx98SLs74M7Lr9NqlESKVZwxGi3otoe4y4id1h63br6EUygh6wZhJnF8\n6y6qYiAhRE2dTpdnz54zGAwZDIbMpnPCMOHs7FwwttOEJIpIY4FTjJIYRTOYeS5z3+fkqosbxeim\njaFbaLJGlMVIioTvB5Bl4k1omkiKTBSIzn4yniFJrFGHX+N0rztd27YxTWNdGMQ+cCM8E+NsUSjF\nzUUUC21d2NP1bnkToLDZb28ea/NL/Bsxas5SSfC5U7GDF0wPdc08kSGTSOIUVTXQNJ04jUhSBUlW\n1mETGTk9JYqnKFlIMWeIkbUsk8vlKOSESj4jEyCRcplCoYCqqtcc5igJyZKYYLUizFL84jsAWNoc\nS9VYDAc8e/CAwPdJESlvSZyClKEqOuY6JUqSJOqVCmkS8o1vvMrNwwN63S6j0ZBkvcsXTxakdb43\nWYZtaNzYreBmZWLZwZKXmMzIpAxFFSPYNE25efPm2hcsxuSqKvb6GyveJkJ0E3KyoepJEmSxEFXp\nls14PME2dRxTJw496rUauqEjy4qAO4UBOzu7RGHExeW5iMVdH4D6gwHT6Zzt7R2q1RqWaROGEb4f\noOkmxzePUHVDjJWljCgSh41Bf4jj/Bh44voeUQa5QpkgzkglmbxTwF+u8IIIRVGv/d2e512P1FMy\n0TXX6qxWHp7rsVzNydIQJ2eIaWGSrO9pPUBeX1sxjpMjDCJmi9n1WkfXdXK5HL3egNlsjmVY7O8d\noMgK0+mMZmOLXrePtL7uNVUnCiKm4ynlYlWk9Kk6lmmTxCmL+RLLzBHHCYHn8/7777O7u8v5xQWL\nxYKryytu3Lix5uGDbducnp1i2yY72y1msylBEBB4QjsRRhFBIKYHh4dHSJKM49hkWcJoPGI8nnLv\n3st4biB0B6qKhCji4zVF89Gjx7Ra2+zu71OvNalWG0ynC3w/4umTZzhOntZWk+Pbx8SxaL5kRaLb\nbeMFLoosMZnMURSVyXjMfDEjyzJG4zHz2ZL7j55ApmPkyki6yRf3H/PwyXOu2gOm8xmd3oD5MuTi\n8pI4y+gPhtQbW2zVhUpdliV2tpskUcTu9jaPH9/HSxPe/tY30Q0dTVOo1iu8+eYbHB4c4Hku27t7\nxElCs16nWCiQZRmDwYB3vvsdgigiCITIsbF/76e/gP/P//0/e3c8GqPqOoqqks8XaF+1iaOYzz/7\njPv3HzCdTun3huwf7LG/v0ehaKNo0G5f4C7ETX+1XHJycsJWa4vJeMjKXZAv5OhcXXHr5hHz5Yr7\nj17w8PEpP/Nzv8z9+w+xbJPf/u3/lCePH+C7C27fOmI+HnLr+Ah3uVzbXiIWsxmNWg1dD7Ftg5OT\n5zSaTTRNw3FymKZBLpcHZAzDpDcYMRgO8X2PMAg4OjwiSVOevXhKa6tO6HlUyyU63Q75XI5Wq8Vk\nMmE4HPD00WOObh7SqFdJk5itrR2yLObxs6c0W7sc3TwmyWJOLy7p9Xucn18I5bKsUKjU2D04olyp\nkZERJlBr7jAc+ziFGoZTpNE6IFY1YhQueyOaW3ucnl0iIXN+ds5yteLqqk25XKFQKLJcuORzBQzD\npN1uc/P4iGqthrtaUSmVefj4EYV6ncxQUSwLL4oxrAJBnK0j/HwUVSWMY6I4IWfbJFGMbVmioAcB\naZiwnLusXI80Sda+ZEmAOtY2LlVV18SpDXAlu1aPp2m6Bp+E1xCITc504IuuR11bxjaFY7Pz3uwQ\nN7Yx0XVkRFG0DuaQ1o+RoWk6YRitDwjp9WdJVvB8nzT1sLQQVfVJwyVq6CLLKTExedu6tsNtCpsk\ny2i6sJsV1znvrutee8A1TQNJRlcNkkRCs0ssrNeBlM6z93n+6AGTbgdVAtsqYJo5DKuMYTqkqULo\nzghDn8jz2W7Ueeubr5NELpVSjihYkbNtzk9PcCydJI6RyajXaty+dQsJmC/mZHHA8eENNAV8qYSf\n5bD8L0mTGN8Pru14G3CHaZrX04R0nZC2ORxFUXRdmDbRjGmakbcdXD9g6XkoikwWxahShrtYiOQm\nWRT+zWMsl3OCIMDJ2QRBgGEY1Ot1ojjlzTffRNMMms0tfD+g0+mSJClBIKh9tmMRpymkGflinihJ\niDMZzczx9ne/R3cwAgWKpTqyZgIyi/mc85NTquUK/tq3n2UZ1Wr1+gAxGo1I17bDxXxJt9unVCqy\ns7PFZNJnuRqjKELEV6830DSDfk/gj2u1Btb68JKlKVvbW1iWda3RaLW22d/fFznpisLlVQdN01ku\nV+zv7WJaDoPBEMcRDhVV1fBdD1lRGY8nzGZzNE1nsVhSrVa5urqiNxrgBj7z5YLheITp2ORLRV66\nc4fZfI6sqkiIwB8Rs+yhrvMBgkDEMPd7XXTDoFIpY1oWpmHgOLZgq8sKmqZzeXF5TSw7OTllOp3z\n5Zf3sW2Hhw8frCcxMl99+RX/2x/8IR++/yEPHj3mzt17zOYLbuzvo6kCmRtGEZfnV0ymU9qdDtPJ\nhJOzUxazJZ7n8/DhQ85Oz6hUa1xeXNHrD/HCiLOzPpe9EZ89fMx4vuT5i3OePz/lpdu3aTS26HXb\n2LaJbakcHuxweGOX3Z0mUezz6iu3SZMQz3NpNCpEsS9WYMBsMmJ3e4vWVoNyXkSb1isVQt+l4NhE\nYUApX8BdzvFDHyuXX8fKthhPZhze/eZPfwH/0z/4H9+N45hKtcpiueDzzz5DAtIkwXU9YeGRVPb2\n9mhuNUhSH9vRyNk5oiDAMEwKhTzj8RhFUplNpxi2iq5pPHz4kGajjoxMoVglSlRiNGazFWmW8gs/\n/3MkccBo1OPbb71BuZjj+OgQO2eRpfD48SNcd0W5WAQSdnaqJHFCrpAjjjMUWcOyTaEejmA8nCJJ\nMovliiSJMTWVo6NDHNth4c7RdY2dnRaB5yEBw+GASrFMt9vjxckJ21vbFHI5igWH4WiArMjYVp7P\nvvwCM5fn6KV7DEYjkEWP1Nja4tVXXmF//wBVN2i0tikUy2SSgqQo2Lkihl3gsjeh1tpDt3O0xyMe\nn5xy2R9yeHCLZ09fcPL8lPOzc/b2DoijSIzDLi6RJJlCoYCumeRyeRxLQ5YV5gtx4vU9jxtHx1Qa\ndU57l/hhSK5YYbXyURQNVdMwTYMki7FtAd0AYSPSdY0wCll5KyI/IYoiDN1A1wwkma+FX2ji/2YZ\nhmGgKF8fwaZkWYppGiKhTGJ9oxZdjdgvC1tWRiY6El0jXSNSN13iRg0eBJuCJEa/G0uZSCoz1yNu\nGU2WMTR9TXvTQJJE3nzeIYlCDMdBlVSUTPy9amoEnhgpbwqzJElkkkQYRYRBsA58ENnaq9XqWsgX\nBRFSpmBaOULJYGneI4lD3v/X/4L5uMdsOuW/efddSoUGimpSKDepVKqUC1WG/dNr+1alVOTVl+9S\nKjromkzBMbn/5VeEgUc+5xCFPkmciG5V1YmjSEyXSDg+PkJNF3hKk0TJYTHBkhciLQ5JUOjW64lN\nxnccxyLKdR0XClyPzyVJwrIsHMchTVPClYsfRZiWIJPFYYi/WpB3HKIwoFzKoygqhUIBwzAEPCf0\nhCdaVchIyeXymJZ5fbDyXJ84jtB1ndu3b3NwsE+31yUlJU4SltMZri8Ol5ZTpFit87c/+oDpYkmu\n5BBFKZaZYzlbspzNkWVBqAuihK2tJtvb2zx58kR4sXVNhJUkopNWFHV92EgIAo8k89A1idl0habq\nmKaJ63ridSpWePb0qbA5rTGbw9FgnRAmnqOkSKyWCyrlCoqicHZ2Trvd5sXZKfPpBHfp8uDhA/r9\nPoqiUCqVcFcuhWKRfr9PHMfXlktYWzIVib39ffrDAfdeeYW7L7+M4+TwfJ8wCPF8n/FoRLVWJYpC\nSsU8y6VQ52dJSqEgRHz1ZkNMP/oDVssV3W5fWPd6ffr9AZ1Omy+//JJbt24xGo0wDPEaua5LLufQ\naDSYTmd4fkCz0eTyqs3P/MzPMpnO8D1X4G3JKFcqvHh+wmQy5bLdoZAvMp1NuLy8orXVYjqdMRqN\nWK1W4vA5X7KYr9g9uMH5xYClGxAhsVj5KLKKoZkoCFX8zlYNTcm4cdDi+HCPWzf3sSyNYtGm1ary\n+ecfMx5PePrsMVvbDW7eOGbQ79Js1CgVcshSxscfvo+cQeQtyVkWWZKQxiGh511PJPrDEYPRBN2w\n2D+8QWP3pZ/+Av7D//Ofv5vJMuVqg/5wymQV8OL8iiiCUsHm6OgAzUjZ2W3g2DluHt0m9COx30uh\ntbWF7wUgwcJbEksZk/mK8cJntop58uyKTnfG6VmHar3B0fExrrdCV6Feq7Ccz1E1jXpri3/1Z38K\nqkK+VMP3IwpFm2LFZme3Thj6BAk4xQpzL+L27VfRdIfecIwbxUwWSwHIUFTiOGY+X7Ld2qFSrXPV\nvSDv5NjaagiFaKVCHEWYuk2cpPh+gG05KKrEZDbEDVccHO2TSRk//LM/I18os723x3gyYDjo4VgO\noeejpAmz6VSogGWFeqOJ6wdcdtpUa7s8fX7GbOZSKleRJUXgAiWZnJXDUIV6NwpDKpUKNw6OePzk\nCYqksFjMgTNrR+cAACAASURBVIw3v/Emvhsxn8+Q1IytRgNTU9nfbVEpl9GcHE6lykW3i6wYZJKC\n74UYlgFShqwoRElCGCdiSiDJeH7AfOkRxuJGGkcJy9hDsw3CLGIVehimGHNubugbr7aAsCh4nr9e\nD6QkiUj0iiKhcpYkhSTJhNo6FaPAIIxQVBVZVcX3EARkkoSq6yDLYi0gSTj5PHYuRxCFQkVvGSRZ\ngmEZxGlCvPFUyxKZhICZKDKKKlTfAtCQEXiCQZ7KkJKRxul1d79RxAdBQBLH6OuM7E1xA67XArqu\nE2cpceJjmjpJIrEwXxExsVmfw519fvMf/Md89snHfPTBx4Rx9mPspGJwfnkfVRUxhsgSxzdvkkQB\nMgJc8cF7n3Lvzl2yNGMymqwD1lJG8xkrd4GuKARxytJbCd1DHBLIZUIcavIJmqISRgm6pqFIMroh\naGiu6woB3toxsNnrb8bo+Xz+eiWSZRkLd4aim8RJRhiEqIA7G2NrCq/cfQlFVRkMBmtwSoZqaCRp\nxmQ+xfMjKtU6aSamMkEQ0GjUcRdzFqsFkgSDwZDz8wuq1TrrLBl03aJQrjFbeDi5Mvl8kX6nzZuv\nv4EmqyikaEoMcoxTLJKgIGsGCbFICHNy9AdjavUWYRQzmozEAdBdksQBqpyhKRKr5ZLxYEmhtEUU\nRAR+RpYpqIrwc3u+0BMMJ7PrVUe7f4mVM5nOJnS6bZIsFI9pFzm/6LFYeiwWc+qNOhen5zw/OaFc\nq1CpVck5hsCqtrYZTEbYjkOSpYzGI46ObxKnCZqhs7vd4vzslN3mNkkY0bm8YtDrMhkNiGOP8/NL\nZrMphqFRL5f49KMPsSybfKHEauXzwYefEMbw1YMHdLs9kCQGwwGD4YivvnrIy6+9xovTc/rDIYZl\nc3jzCNsu8gd/9Mds7e4zGE04OrrFebtLvlwCRSEBbhwe4RRzrLwld+7eZj6dUswVKJXyNJtlPvrg\nPfZ2dznYP+QP/vCP+a1/9I+QJI3//Y/+JaZpUC6VIY3pddt43pJKqSr86JpCHLjMxj1aWxW6vUvm\nywGGnvHKvZu0tmq88cZrhGGwJskViKIEVbUJIyiXq1h2jv29Q9z5TKxfVJ32xRmxu2K1nHHn3h00\nQ0WRU87OTigW8vhxwMPHTzm9uOJ3f/d3uX37iIKjk9MlSjv/Pxih/w//3T97NwhTnr04pT3sE6YJ\njmUz6g/Y3t7i+OYRpXKBw8NDlguXZrOFblsiG9oUNo4gCLFyBbq9AZ4fMhj53H/4AiSdJM7Ikow0\nEx39eDLl9ddfZjLp8c53v4NliVSc6WQCWUZzZ4vW9j7PX7ygVCtSKOWwbAtNN1i5EVGSkqQpk8mC\nlIz5csV8tWQ5n7NaLojDiL29XZq1KqVSicvLS5oNkVTkeR6aovLVV19RKhZZzOfoukGn06FQKDCb\nzdjZ2eb1N14ligSsJE1kvvPdd5jPJqiKxHajzngwYDlbYNsWrVaLXL6AF0Q8ePyEJINet49tl7i6\napPLFVBkFX/dXTabLXb3tlBVmcuLU3Z2twgCMbp03QXFQpler0upVLxWumqaxmQ2JokiXpy8QNM1\n3CCgMxgSru0wUZyRs3NCQBUnKLJyDYewTJPVyiWKIlxXjFd938fzfBFhmWVrcaGK4ziYunGdSqV8\nDW26+dh8X5suddPVpanYc3+9WGzGuJu9YhRFFAqFn0gZ28BgNkjVTTeurYvrJm7QMAwKxQLzxQLP\n90CSrhXz0jpPfDPW37DVgesVwNc951+3pm3snBuM64938RsGvY6sKISZwdK4h6pklLQJv/c7/5Ao\nXPLDH/4fDIZtev0r+oMeWRLSbZ/i+wt0Q+O11+5x585L5PIOpBKuH2Dl8nz6+QNWK4/5ckUUx2se\nGwgpnsgWB5jOlhRyDjv1PLO0RKIUUfwr5HixFtQFSIC/dhds1hfCn++QJMIJsHldNkV9gz5dLeck\nqShmq+WSUj6HKqU4pkG1UqLT7XJ1dcWjR4/XmeAStVqVYqHE4eEhjuMQJTG1eg1N14nCkLOLc4Ig\noFAoACJpCgQet1KpUl17xLe3d1EURdAYd1pYloljafjegjDykchY+S6GaYKUkbNMQj/A0HQcyySN\nI7zViiSOIE3JULGsHEEQUyjXePDwKTt7Bxwe3uSy3RXpbKbNV/fvoxomnV6fy6seSRpiWiaSItwK\n89kMy7Sw1u6E1cIjzWRmswWz6YLlStxr3nz7LRrbW5TrNQrlAt1+F90y2Tm4QRZHGKZOksS0trbW\nUJ+MwWiAO3fptLt0O332d27grw+d49GYp09fkLNN/uxP/wzHsvBXc0aDAZqm8fjxE8bzlPFkhRfJ\n3H/4mP5wSrW+zXsffMpkNGM8mdHvD5ktlthOAdvJs1pFvP/Rh7z3/kcMJ1PqzS0++ugTQOaTzz9n\n5fqcnZwz6A84PTlnNp0zGox4/d49XHdMqZzn3r07dDodvFXI8fEdSuUqk/GMt956nQ8/eg/HtvjN\n3/wNlvM5d+/e5fnJczTNotvt8fobr7FaTRkOOrz15uvcu32Ll+/e5Hvf+za721vUa1XyeZELLiGT\nrKd8nudjGobAGvs+y+USP4vww5BGs04aRXSuLmhWKywmM8y8Qz7n0O/3qVYqDEcj9nb3KRRLxHGI\npRtoqsRiNmXr+K2f/gL+X//T/+pdRTNJs4z9gz1Onj3h9o1DWo069+4eky9Y1GoVJEli5ftMZnPC\nOAAUzi8vUTQdZI3FymUwmTEcz7HyFYIwXt9sp+iGxMH+NvP5hJ/9uR/gBy6/9iu/xCcff3wdH9hq\nbXHr1jGNmkjKmo/H7G+30FWZ0BMexXqjSeB5eK6LnGVkWcyLF89oNKvkbZubN29yeHjAfDKl2xGJ\nQtvb28zmI+bzOZIkMZ1MOXn2DNu2CPyAp0+fMJ8vaDZb7Ozs8L3vf5enz54wHo/EDTCXB1Kq1RIv\n3bnF5dU5vrvCsW0Oj24iyTIPHj7hqweP0Iwc80XA/v4xlWqD7e0dTk5O0DSdfC6Hrpk8ePiAp0+f\nM58uUGSNyXgm/LfTGZblIEsKsiLRam0TBAGSJNPtdygUCzRbLSq1KpKigaLgBRFeECArGvl8kSAI\nCf2AbG3XS9OUOAyRJbHrzjLpery6QZrKshiBaqqKpMg4poVpmihrMZSmqtfe4k0R2Ii8NvvsTcHY\nCL82BX1jsdl0tpud9+bzZn/59XCPzXh+U0g3X2tTnH3fF4loa+yqaZrXf94U5M2IfHNIAK4Lta7r\n61xr7VrUtTlkiJ+3eE6bD/F8hec5lR1c6x5SGlGSBhTlmKdPH3N2cUqG+DpB4DKd9An9GSBG9Koq\nc3x8kyzLmLsekm6iqDL3v3ggik4iokXTLAVFEla+9a9MAmSJk/NLHMehXqvjZQ6pWqDGOSmCXiag\nMcq1R17YA5Prn/1m+rD5ORiGyINOkkSsTAyLKBb78YJjE7hLZuMhuq5iWuZ1elmpVEaWpLWCXtCz\nrq7amKaNJMmoqsZisSRJUm7ePEZRVAzDoFarYaxZ+5VKhUePHvPkyVNyuRz9fhdFUWg1RSCP684Z\n9HsU8jlkaX2NZhKu66MbOn4QMBgO1te8TxzFuCuXYrGEvmYo6JpGskb7Cruoj2MYGKZOuZJH0xV0\nTaJaKpLEIa29FrqhsdXaotPp4vshYRCjSjr1ep2zszZpqtAbTNhqblEuFUVRDmIM1SKNM9z5imZl\nC0s38VcRi3lAlioossF4vOBHP/qQIEgplmr85d/8DW6QsL1/yGf3H3DRGSAbJnahjGLYNLf3COKM\nMJWZLV12Dm4yWXg8enbGMgjp9vtImoIf+gI57boMRiMMR1AUp/OJCBGyHZYLl/PzNoPBEMO0KObL\nmLrFwweP16jTKeWKILT1ewMGgxH9Thd3teKbb7zGjYMtrtrnyIpEIV9kd/eAbr+HrCmUyjkOj/a5\nd+8OigLf/947WKaIWD07v6BWrQtok5LxT/6zf8gXn33A/k6Tn/3Bd4gDl0athO+7Ao0qq8xnC2w7\nh0TGeDJB1w2WyyW2bTMcDpmMxpiGTs62sQwDiZTtrSaSCl4UMl8uCHyf4+NjFkvh3d/d3aNWr3Fj\nf5cg8NE1lSiMaN5886cf5PIPfvn7Weh5TLuXNGtl9vca/P7v/z5BEPDv3vt7oijANG2WC5c0Uzm5\naDNZ+tTqxWuYRmtrm4dPHtNoiBF1pVLh537mB5iGgkLGcH169FYurutz5+7L3P/qEyxDJwp9VqsF\njUYN3dDIF3NCaCTJ+O6SOA6R117JVEqwbZvHDx/RH8xoNFtUqzV2drYxHVug+4YDZCljMhrjLgT0\nYv9gl7OzE1577TUWizm9Xo+X792he9VG0RVsu4Bl2viBx2o1QzcUskwUuN2dm2Js5fuMJmN63QHV\nahNDt+gN2zx6+IRao8X3v/fzfPDhZ0znHpPxjMOjfRRFjCvb7Ta2bXN11aHT6XB8fEy73ebo6Ijz\n83NKJRG88fDhQ7KMawZzs9kUUZrFAqkEiSSvE5fMazKabhpkmUQQixFxRnItKFvM5tfFb7VykWWV\n5XJJsVjEsqzrjG8QN+58Pg9wvXuWvnZ9bgrj5vNmd70Rhm0+Nn+/AbVsAC+b4rjpADe76K/vpTd7\nwo0obtNFboAkwvP94xSzLMsoFAqkqYgl3ZzSHce5LlSqql4fWER2uLDLbcbom8fePM5G/AVCB5Ak\nCcq6GK6SHKPybyOnKyqr91idPeVqEnDWd1n5IVkmBHMAMhnRmoGua0Jv0NrZ4o133iFYe5Hbp2d0\nHj8iS4XyPk4hk1SyOAIpIwhjhMQI1k55JM3ge7/1T5FVg/3gz1GjjpiG6AZ+GGDbNq7rouv6ddyr\nsYYpLRYLoYav168PR0mSsFxOCaJMeNZRSAKPzslTbuw0+dVf+SU+/uQT5LWtaTweUy4X18EZWwwH\nvWvMLbIkbDqGwfbuLpPJ5PpxbNtmNhfBJYPBYL2yktexl2WSNKJgm0R+AFlCGifEoS/uMWmKnSsy\nGi1oHrQEfGU+FyjW5QopEQV+MpngBgI2tBHW+WHAcrlkZ3eXXrfNYiEmd8VintAPsCwHx8mzGIv3\nimk4vLhs89kXX3Fj72D9Xr1ivloxGk+pN1s4lsG9uy/x8KuvCPwlDx49Zu/gkC+++JLhcMD+zi62\n7XB+2SWOY37m537A559/Tq/Xo1QqMV+67Oy2BIJ0LfTagHUsXSNnO9eHVU3TrpPxVu4SVVa4c/f4\nerp4dHTEcDjk7/7u7zg8PGS7tcvjJ/e5d+cmnc4ZnXaXZnOHy6sOv/rLv8J7P/oRURTxxmuv0thq\n8uzZMzGhMi2kDD796FM0Veb3fu+fcHb6jLffeIU0i6hUSqDAeDCl2xlQLldRLY1USrlz6zadfpf2\n5Tk39g/wVz6rlUujvkVvPOTyok21VqbXaeNYJqVSGUPT0XSbcrlMdzIA4NmzF9y69RK2YWHaNuPx\n+Pp9fvv2bWYz4RA4OTnBNk1yuRyqLJNkMXESEocR1XoN3/eZz+eUy2Xa7Ta3bt3i6uISWRf3G00T\ndevVn/nHP/0gl0///E/eTbwl5bKDpGZ84+1vMBqPUBSZ+w8+Q1VlCoU8o9GYpeeyvbtDtdlCNyxU\nTWd3b59ef4DnuRzs7mHqGjf3G1QKJsFSRIzqukan0wYpYzYZEYYxg14bWcqYT8YUizl0UxWpOJqK\nY5lcXpxjaDrD3kDEFPoew4VLJqvkSxWGU497r75OtVpnOBoRektePHtGmkQU8zkCz8V3XSaTKb1u\nl8Ojm5yfn12Py09PXrCcLwjCgHfeeYfhcEi326ZcLpHL2dy9ew/bdnB0k9FwzCcff0YQJJxftDk9\nueDTz74kiCxae8cc33qZF6fnvPnNb7JYLAhDj35fgCBevDjBMEwsyybZxI4aNqZpk6TJ+mZr0O8P\naDSaHB7eoFKp0Ov1BP0pjinXq/T6Q1TLIogzvCAkyTIKBQHS0U2LpRdgWAae7+GvixmShCzJ12Km\nLEuxLPGm2RQ6WYacbeHY9jVARVUUDF3/CYLaZuy66ZC/Pnre7Mg3grNN4Q7D8Cf+bFnW9dj9695r\nQW5Trx9n8/sgCK477c0YX5FkyAQUJkszNFVdQ1ESkvWOfNN5bvbam+9zkx++Ec9tDhXA9SRho9L+\nuldaWneviZzDNe8gZyH5rM+43SbTdHqTIVEcI0kq6QZLI2VkKIAY8d+4fcTx66+RApJkgKSSL+XI\n/CUFXYIkQgEsXSPv6FimhqZCuvHEI8brMimZrFJqHpIqDvnkREwQZIU0S68nK5vxub5+HTeHog3L\nG8DzvPV1YGFaDkkqADOWYZC3RBrXar5gPJleq/Nns5norCWFv//7vyP2E/JOgcXS5eT5KWGUMBpO\n+OLL+xSKZT795BNmsznL5YJypcx0nV1u2w6SLFGvV4njiDRL0FUFSZFxVxNsy4A1hUyW4PTsBfv7\nh+QLBqvljF6nw8nz51TLFSbjCZ3OFeVymTRK2d7aZjwYYRsW3asOo8EIkoydZoNhf0KtVKNarNC5\n7NC96jAZTDDNPNPJkm5/zF/97XsMxnNOL6748JPPefrihPc++AjVMDi9OENVFb784nM63Q7tqy5X\nnRGPnp2xWPp0eyPK5TrPTy65feeYdqdDvV5DWQeVZFlGrVpjd2eb84tLOt0ekqISBAF7e3uUyiXG\noxFRnBIGPovFgvF0xngyYTlf4OQcDne3cCydRqXAh+/9O/6TX/8NBt0ORwf7LOYLDg8OiaOE+/fv\nY5o23/nOd3jx/BmxFPCtb79Jt33G3v42b37rDd7+zje5vDjhYH+XciHHL/3Cz/L9738bXRdT0+lk\nyGjcwQ+WREnI9s4O+7s3yCSVl166h6xoTMYjdE2j2xWe+t2tbcggjkLCOGA0HvJrv/ar7O7tkmYp\n9XoDWdKwnILg4E8ntFpb2LaDpuncvXeX+WJO6HnsbG+jqSr5XI44ConThKKdY9DpYRkmTs6h1+9R\nadaYTOcoskShUCBJEi4vL8nn8yznM6rlEu1OB8s0iZOUUqlCaevWT/8I/dGHP3w3TQLe+cF32b2x\nxy/+0i/x5MkTPv7kE0xHAByWixX5UpX+cMje4REX3T697oDVymU4GkOWYqgqu60GUhYiJUtGvSui\ncEWve8lyuaRaL6MbCuVSDlU12N6qslpMyeVtdna2ME2NOApo1pvX3GgpE9bYR/cfkmUSoazw7MUJ\n915+nd39G1RrdSxDJfRWqIpMHAUMel3SOGSxmPMLP/+LdLsdqtUqZBAGvrDFKArHxze5cXCAuhbz\nnJy8YHt7mygK2d3bZTSakqFwenbJv/yjf8W/+cu/YTCcUSo30AyHl195nUp9l/F4Rj5f4suv7vPg\nwQNyTg6klEq1Qb8/wLYtBoMBnU5XjIEllWKxzMnJ6f/D3ZvESJbfd36ft8ZbYt8jct8qs6p6ry52\ns9mkRA41kqgZSYAg2zPGYC4G7KsBA4YvBq++GAZswLANS8ZgDAvjZQCNONJAI1ESu8lmU+y9utas\n3DNj31/E258PL150cS4+CAakyUtlVkZmRkZGvO//9/19F15//R6PHz+m3xuQzxXImhkiQp4/f06l\nXCNfyMWWMd9HkFLIKY0giohEmVw2jyJKOI7NwrZRNYMoCvFsF4SIcNk2lYBZFEE+n0cUBVzXQZJE\ngsDHeKEpDFhNxwlAJ6CdAFoC0sltk+n7xTCXVU3mkhpPpnLXdVfPO1EUMQyDIAhWk2FyYEi+3jCM\n1W2TlUAQhswXc9RUCkEUcT037vR+4b4nveYJWPm+jyBJpDOZVXiMsmxaU1Mp5osFmq5jzedIsoya\nSmHN56Qzmdhr6y4wtBSCWmQi7yFFDo7bBs3E9mzm8xmeHxAQ4EchyzMGohjnyr/0tXus7e0iiCKO\nLSNnXkdUmiA3yTZfolA/RNKL6GYeWVERw5AosNFTKnpKx9RTGLoWA62mIvoTiptv4IpZ5PkxKTFe\nkwhivNc2DGNlL0u80slaIploFEVZsRaplMJoPKU/GOA6DoHncXV2wu72FqPBgEw2SyaTo1qNFfae\n4wERV1fXNBuN+DkSRbS7nRVjpKgqppmhVC6TSZuYpoHjOvi+S7fbWR7cbGazCYoqYRg6KSVZ1whM\nhhPOTy9ZLGxOz07xg4iD/dtM5iOurluMRhaO6zOd2hiZDOlsni8fPUaRYsGdaZrkcnl+8tMPCIKA\n0WTKo0ePObto8eDLR5yeXfLFg4c8+Pwh5xeXPHhyQqc/4uqqy3jh4kQhqq4znVtcXF+DFIswD/YP\nGAx7eJ7Lyclz7r39FpbtkEqn+fzhI1K6Tn1jnZE1JSUJeJ7D5eUlr736MgIR4+GYUn657vIDbM+l\nUC5imDqGoePZCyqlEtlsGl1Tub6+JlfIUyjkuXPniNPnx+yur1Ep5Vlr1NhZ30YRZSbDURxjm5Lo\ntFs8e/qMw9t3+c3f/E3+7//nX3B0dMDbX79HWlPY392mUi7wyit3UUUBMfTRdION9QblYgbXmUPk\nI8sioR/ntNcbdTRdQ1FSPH12QjZTiONTVY1uu0V/NGRzY4vZxCKbzdDrdnF9FwHY3d9nOBkhShLH\nJ6fUGmvky1X8MGQ8m7C1tb5cjck4jk25XKF9fUWjUadSKdPv9ygU8gwGfQa9Hgoi7VYL3/UplIrM\n7Cl62mSxmJM1dG5a7VXDoSSIHB8/o9NuxTkPmRy+F4dCVTb+PRCx/dmf/e/fv+5ccX5xjqGmOD4+\nw57bKIpKobjBxVkb3SiSy1a4vulz0x3x7OwaSRSo1Ru4jo2iyOiqws7mOvm0wbjfZ2tzk3qlShgI\nzBZxQpntuGSyGRaLOcNBi8NbB5RKRUajEamUiixLdIZDLNtmYs2QFJX1rW2am5vYjsv27gGmYVIp\nVymWyvR7LTo3l0SuRSabYTToE4QekijS73Vpt7ucnZ1xcHDI+fkZh4e3SKViGnZ/fw97vsA0DMaj\nCfVGk93dHQajAR9++DP6/SGeG/Knf/Fz2v053/uN32Vt8xaimubO3XuMpjaR4PP0yTM+++wLtrZ2\nsCZz3v/xj1FFhcVStOb6LghQLBTRUgau6zOzhqyvN/jJT95D0xWOjg5w3QWKLFAslbl7N+7PvW61\n0E0dx4sV44EQoaS0OCnNmseRnK6PH0bYrkfoBTE4CwKEsdzXsW08x6NcLa/o6mRHmuyVZUlc7caT\nIJAEbJPpNVhav15sDgNWIJn0gie3FQQB27ZXn3+x5/tFGj0RvSVCt4QeT4RtyeEh2VcHy95xQYwz\n9Be2vRKAyctJPTlUJD9HlmMRYTLJy7K8os+TIBnDiFcwyceiKDKfzxFiHxiyKOGRZabsEUQ+XtAj\n1HTUQoXKzj7VrS3W9/fYONhlY3+Xjf191va32b61TzqXJfADOuddlPQBKSNP4NuIkoIgKERKGr2w\nQbp2SG79VfI7X6O4+w5m7Q5acRslU0VIpQkEcXlIG6Onc6QyDSJJx3BPWMwtUtpXDEdCpdu2TTqd\nRhTBdZ2VkCrpP08sWI7rI0oSURgRBR6XpydsbqxDGCArKer1Op1Oh9FoxPGzZziOy3pjjc8ePOC1\n19+gUquxvr5BoVTm0ZMn3Lt/H0NPr8J8BCFiPIkzIzaaa2xtbMQHKSUOZVFVlX5vwNXVNYqU4vq6\nw3y6wHV8CvkSOzt7SFKa/mKKmc7z9Pk555dtFn7EaLrA8UNOL69pjUactbpcdHp88PFn+KJMazjh\n+cU1Xzw5pj9xObnq8N7PPiKSdDxRwXJChqMxopQiECQiWcVybPwwipkpWSafK9Ab9HjnnXeYjPvk\n81neePMeaSXgzuE+ekrmztEBhiazXiuiqRKuM+all44YjTq8+updKqU8V5cnVMpF2ufXfOdbv8Rs\nOsW1HULXp5TL89brr7NWLbO1XuEbX3uDbusCx5qxu7PBy0d7rNdK5PMqv/ztt1lYQ9bXKgyGHcqV\nLJLosd4scXjrFmsbG3z9G9+kXClQKGZoNsq8+/ZbCL7PVqNJIW1iz2boioI9m5EpFdjd3ebx4wfo\nWgrNUFFlCUPTGQ1nMQsVxK/FdrtLv9/n5VdeJiTg8uoaNaVTLJXY2tyKRbVe/Pp6/PgJ99/6Ggix\nIyQSBLL5PIIoky8WkOS49EfXdZ4/P1l2f/uUi0UuLi6wnTmqLNMfxjG4o/GQbKnIwl6gpFJMZ2N8\n38UajbCGEzrdDtlMjnyhQL/fp16r0azXcBY2pVKR4WBAJAooqkp186W/+wD+R//XP/v+wcFtDCON\n44bM5nO8SMDMZBk7NpN5wNlVj5PLKwbTMYIMpyctfM+jWCgw6A+QRBgNBtSrVfr9HmvNNURFYjCa\n4HghmiLjLoY0qmWKmTKROGO90YjtOIrE48cPGY/7+L7HaGQx7g+5tXuIZqQJRIH9w9sMpzOs8RDP\ntRkNexzubzHt9ygXc3iux3jc48c/fh/bsmk213j9jXtcXp1z7603KearvPTqPRzPZTBokzZ1FFln\n4cYHCsf1aDabPD1+yk8+/IC57dPqzPjjP/0xb7/798kXq6xt7rC7v89nn30KYkgQxnnLWirFeDSk\nXqsiSfGkWCrXuLm5wjAzeF6EpqtUa2UWiwVCIBG6IfbcIlfMYqZ1wtDDd10ymSy5TJ4gCpku5qAo\n2KGALwgYWXNVBWlb85g69n0EcRlh6jp47gJRBMuykFUpTrZaFlGkFAVVURAAXdNi73AQkNK0lS8b\n+AVldgLESSRnMk0nQP+iSAxYUePJ1JdM3okK+kUqO8nLTsA5OTQk4K3reuwCWE7+SQBLok5NwDn2\najvx77YE7+R+BEGAtVhgO84v/KzkkJJM/QlzkEkS/qSYyo3JcBFkCVfQ6QhNInUNQVARlHVEpYEg\nVUEqI2tV5FQZWS0hpwpIahZZzSBKGou5R+uyR4BKbeseYeDhn/wLcuE5trAgCsa0n7zHrHOCb1sE\nUURKgI+kXQAAIABJREFUzyKrBql0CbO4Tr5+i/Lma1R236Ky/y4pswiijCfmyIWXSIKLLCm4bqz2\njnUHi7hX248TuyBCXlaYalpqFeMK4AcRN60WlXIZdz5nNh7x7W++i2mYZAt5FFUljCLyhQKRAKVK\nhdPLC2qVCuPpgGy+iOPZnF8cs7u5yft/9T6i5JHLZel02pyenlCv5VEVkWq1xHg8RpZEeu0Ow96A\n44dPMUwjzlaPNHKFApVaGVXX8EMfRdUIxICF5aCqGR4/v+K9n36EnDLoj8Y8fPqY/nBIrVTj6vKC\n4WjCrcMjnj4/xnVcDF0nrUiY2QKqkaZa38TMFrBmC8ajCbKiUl9rMHfntNtdJATCwMOyJjTrNbqd\nNqVikXtvvo6KTzlnsrfZIJ1SUVMqtw8PCT2X6aDPP/i1X+Xzn39MLm1AEFEp5smYKSrlAhv1DRRJ\nxo5sJF2j3RuQNQyU0AF3yuGtLfLFHBfPH2NoAr/2q+8yG3eZDIfcu3+Pw9v7bG3WyWZNCOH07IzR\neEAmm0ZWRHb2dnHcBfVmnaPDAwa9Lt3rNtVSjd29I6IAzIzG3LJYzOcMeyOc+Zxhv4uZUllrNJEl\nCXtuUy6WcV2faqNBu9PlYPeAUqFMsMwNKdfKtLsttrY3yKZN+v0e1Vp1aReF8XRKOpunWCkxXyzI\nZLIEvs9kPCaT1hlN+lTKJQbtLvY8ro999PBLPN8lmzEolorIssx4Ml758h1nQSQKbO1skc6afPTR\nX3N2ckounSWbzmDbThyiE0E+k6Xf65HP5vE8F1XXEUSRSALD1Cit/XsA4E8/ff/7B3u3ECUZM53j\n5PqG3mjCVbvD8VkLP4DhZELrpoUkS1gLB0XVaXduMHSDhb1AUzXu3Lkbq2gjkcFwiJku8fTJMy4v\nzzB0GT2lMRz00TSJm+tLGrUml5fXXF5ece/+fTw/xExnKRVK9LsDapUahq5zcXZGp9Xi+uKCXusS\nRRIpFwv0Om1M02A2GTOfW1xeXpBOp2nUG9y9exfHWbC9t4euG4yHU1J6iourC8qVEuVqjbSZxgk9\nwigOZLlutbA9l9dffx3DzGBmCvzG936LSrVBoVRkOh3z3nvv0WjWubm5IQwj0mmD6WRCpVIG4kIF\nRVGpVmtIskShWKBcLseCG0kipaYYDeO4QUVXGYyGmOk0a2sbWIsFQQCWbdPp9UnpJrOFjaZrZHLZ\neMoMgUhA1w1UVcWyFiuBVmwL8pAkcRnmoa7EQ4ZhrKwYSaxmAsD+EuwSJTZ8te9OQDOZnhM6/kVq\n/EW7VqzCdn5hh5xM+y8q3xVFWf2cF3fVyWSfTPrA6mtVNfY4a7q+EpolE79hmoTL+5rst2E59S/B\nP1GrJ+CeZIUnCntZlgmW+/YwigiXu3CfkE6QZaxuEi7DakTJIErkZYKMIKoIooYgGghSGkHKIkh5\nBLmIIJdRjTXytVvkq/sA+JOHVDM2P//wA3I5EyklUy2l+PqGzWFxTi58iNB/H8M/pqIOMcURKWGO\nJHhEkUAoqCAuH3dBQPT6KGGHMIip7RiYA8IgpvFn0wWiICEgEYSxb1+SFMJAwHUDXHdBbziiVCoT\nBmAv5nSuL9nf3yMMfbqtDu2bFv1uj1wmg6amKBeLzGcWp2cX3Ll7m163hyQINOslSqU888mEl1+6\niyrLsbioVIQIggCu233CIG70moyHrDVqDIZdioUihm7Q6VzQbl/RH3bQDQnEADOTQhAkLs7PObu8\n5od/8R6CKJHL5inl8tizOWbK4Oj2Adtb66w16rx573VaV5cIocv9118iqylECAhEvPP2W0yGPSrF\nApoq8sYb9zg7fY5r2/R7cbzt5sYajjNDkUVuH+5RqxTZ294kq4kUCxmE0KNaKmCmDebzBba9YDgc\n8sd/8sf8yq/8KvV6lWq1wp27RwhCnEbXXNtEVmRkWeXi8pJ6vcrhwSa39tY52F+jWMhSrhR59c4t\notCnWMhjGmneePNrfPvb346dHkLIgy8eLHfDGQRRpt2OV3SlUil2dkhQKhZ4+uQRe/s7NJo1BCJa\nrXNGwz4pVUWSJHKZHGenZzw5fko+n6der3N5ebkSuZpmGsd1KRUKzOdz5jOLXD5PEAZcX1+xsBd4\nbtxSV6lU6LRidjZh8DY3N9B0neurOCb2+fEx4vLgPJtOlylzMdX+6PEjjo6O4jIYUVppdRK9jmVZ\nNBpN5vYiZus8j7RpIksSGTNN4PvohrHS2iQizUqtFBc8jccoikKlXosjdzde/rsP4Kef/fz7f/3X\nH5HJFhnPbVA1Hp+cxV20kcxgOMDQNK4uz6lWamTzRfLlEoFnU8znmYzG7O7sYM9tnp+c8uWjRwwH\nQ7rdOKFITYEshmxtbKAqMkG4YD6d8/HHn3JxdcVgMCKTyVNrruH5IaP+EEkQGfZGvP/jn/Ds6TGd\ndovN9XUKBQNJBE1RcW0by5qtrDGvvPYG9964x8uvvILreYiSzGxm4bkhpUqFk7Pn3Do6QNVMspks\nkipxedWKd46SShCBmU5zdnXNeLIgjCR6vSFffPmYb3zjHRRFZm9vh3w+x+bmBnfu3EWWBcbjEScn\nzzEMDcf2lraYLuVqmZubGyICFEUjl80zGY/Yv7WHklJ49vwZC9umsb6OICk8Pz1DURTWt7YJEJgt\nbCrVGrbjIMqxtzZO14ovzpY1XwFYogyPJ+KITCa9qsxMAFZaxpkmHuskDzyhkhO19ose6sT2k/yf\naZorIH+ROn9RZJb41l9UqScAnEzSSYuTpmmrCX+xWKxo/QTAk/cTTziAt7z/lmWtTuWiKKLpOpIY\n1yRmlpWNghBTZclOPfldX/S1xypzeVkgEYfKWJaFLMvMfZWOvE2gxp0A6zmNqnCO33qP2dmf03nw\nA0bPf4R1+RGzq4+x2l/iT07xpldEzgBdDZAFD0HwEYWIiAh8i0LwkFIpy1/81fv0Oy3WDu4SRRGZ\nsMNoNMQwRHRNwlR9dGGCuLhAtY/R7S8oR4/JB59jus9g+hwzauP3P0EWRRRJIwoFfD8giiClqQhC\niKZJqCmVIHSRJAEIGY+HBKGHKEHKSMW59oqK53pEgY87nxEGPnduHxGFsY6gVKogSTGd+fjJYzzf\n491f+iU++/xzVEWhWMgiCi4bzTrVSoXPP/+AyWjAYNhhNhtTqZWQVAl7saBcKlHIZcnmTKLII20a\nBF6IhBjvTIdjDvYP8f2QdCZ2priOSCm/xX/73/2PnF20MI00lWIeIZgTOhO21sq8++432N5aY2O9\nzmTUY6NR5tvvvkUurbFRyTIajlAViXfeus/ZyTH1UgHPtXjz3hv83v/6v3D76ABVkhDwuLk+5803\nXsV35/zH/9F/QFZT0OWISt6klMuwtbHOcNBFQKBcKeMHIdZ8xvX1FV97620CZxGXHQkRshxx8vwY\n3/W5c3QHQRTI5dKkTRVZ8tHUgJ2NBoG/wLMtnPkUXVMIAoFsLkdExIMHn6HKClEYkMmkabValIol\nIgSCwKfZbC699U3GoyECIaNhH9PQIAogCuh0b/ADFzOd4fnxCflsnmajjpxS0JeH4wcPHrC/v49l\nWZRKZXzPp9/vkzZMMpkM88WcaqVCvpAjpaoMB33mVvx8abfbK2ZuxeBJEoHvxzkflSpmSsdd2PE6\nJ24xoj8YUC6XY5thobC6ZgyHQ2Q5ds+YphkXKaXTeJ5HIZ+n1+1Sr9XJZ3OEQUixVFplTtTrddqd\nG6bTaew+iOKmtFqjTqFYxCjs/t0H8P/mv/6vvj93feaex7Ozc44vrgmCCEGUcew51WKW7Y06uiZz\n59YRQiRwdXFOv33DvVdfYbPZZNjv0r6+5NnxEwqlPNmMzuGtA0wjxUsvHVEtl/G8AD/0OTk9IQoj\nLq9arK9vYhhp6vUGKUXFni94fnxMPlfgB3/0Az746QOO7uzx5v17ZHMZwtCnmC8uxUsBG1tbbO/s\nkisWUBQN2/Ho9PoMxkMcz8MwMgwGEyIhIlfILDO5dXwv4uTkGGs2x3dczs8v2NzY5i/+4kdsbu2g\npgxmUwdZNdB0g8XCYjwesX+wQ6fbYjAY0G7f4LgLPHeBZU158OABuqHheQGKInN4dIfTs+dUq2Wa\nzQ0qlRqj8ZDnJ4/RDYNcLkulWuPh48fs7O5TKJbQzTQXrTazuU1K1wmjCCQZ1/EJ/AjPC+JyiIWD\nbTtIsriaNiVRQVFkSkvaybbtVdJWMm1GS/AyDGOl8E6mcl3Xmc/nSMvM8mT6TujtZOJ90YrlBcEq\n4zwJPkm6w4HV1ybT+ovTb3ZZMpCAa6J2TyjuhAVI9uixZz2mtwGUlBr7fZcqa4irSSVJYjQafeWD\nXtL2iUc9qT9NRHGqquIHPq7jwtLuFgmgySqdqEigZjFViZuP3+Mnf/qv+eTjz3n87JzWdY/ReBkg\nNOwz7V8x6ZzRu3xC6+xzOs8+IuVccFATKCt9rIuf8eX7f0BRvCFnKpxeXXByeo2iaazv30EkwHAu\nMTImYhQRBuC7EaKgIsoKqZSBrptEkYg1WzAbdcmmPESnQ9ZMk1JUIry4zlT4ylMPsX9aEETCMH6c\nDcNE1w1MM73MK7/EcTzCIEJVVKzxmKypUyrluL48J5JERpMpqpbCSBuEUUR/2OONN9/g6uyKfr/N\n4cEhsiIShQ69fodHjx4xGg3jDIRsFkEUyRcKEAroKYP1tXWePj3mf/jv/2e+9a3vMhovGA8tFNXg\nun3D2fkVzeYWhXIB27X57Isv+f3f+wP+8r0fM57OaKxtoKgy//Sf/CNee+k2+YxGo1rhlVePsCZD\nxsMeYuSzt7tFShE4O3nMuNNhZ3efSrlMuVxCVSQa9RqFwvLakssym4xRFYGv3X+NQfeG3/2d36ZY\nMBFDn6ODHaTQI/L9mCIej5lOxqytbXDTblMoFplOZ9QrFWbTGYHrUilX6HSuKZVyRGGEJMZTs+Ms\nGE3GbG1vsr7exF3M8V0bmQjPsTHMNGEYYqbzKIrGzc0Fk9EQVZYolkp0e11G4zEbm5vMZlZ8qLfn\nbO/uQBQxtyxURWJuzcikM3z26acc3tqnXK6SyRXIFYpcX7fZXF+PkyjTcTWwIAjkcrlVBepkMqXX\n6wPQabcJgoBeN46ZnlsWj588Ip1Oo2sa08kEWZKYzaYslpWvSWtcLpNlNp0RBiGaqjIaDpFFkUKh\nyMya0+52yWWzZDIZDE2nPxhg2zbdbpdut0sQBFSrVRzH4eLqiiAIMHQD3/OYjMc4C5vzszN29/Y4\nPj5mY2ODL774gnTGpFgsMpvN8Hwf23W4ubqm2+ux/9K7f/d94P/pf/K70bNnz2IRiyixVq0zGgzj\nOLss3NrdolouMeoPmI0sHj8+5vbtQ5rLwP+z0+cUCnlcz2Zzs8lkNkERQBADptaCv/rLnxGEAq++\n+gqHhwf0+yN0TUKWRez5fOl3XPDee++xttagPxqzt7fH1+6/RalSxgsD5paN4zjYzhwjpTGbzdjZ\n3qLb7S5rMX0WVuz5RpTo9XrUajVSioypG/T613z0yce0W33W17cQgghVFNnYWGNhW+zv3eL8+gZN\nT+MEkMkWmDsuKc3g6dNjtrY22Nra4PLiDFmWKZVKzOYWs9mMwPNXJRF3797lL//yR7GQaC6SL2Rp\ndVtMZhPW1tbI5TJk85klgCiEiFxetRhMpmSz2dhWpZtLi1MMlI7jMByMVwAmSRKe76zEX0HgLQM2\n8iuAjKfZuBzENE00TWM4HMZd20uQSgAV+IWJN4nLBFYAngSfJFO6pmnx5EtMhYXL4JgkRzzuQf7q\n603TXCnNkzdd11cMQqKKTt4HmM1mvzC1J2yAtVgwm83QdX2VQxAsRVvJZJ8kzcU51tJq6jdNE/iK\n6k+ayRIGw3EcJCU+YKQ1nV5YYKxUcQeXTK+fgSRg6kbsaPBDzi5b9LsdJCGmZVMplWIxT7EYdx/n\ncgbIEkgimpIinTaJooCUopArNfi93//npDSDd//hP0aKPFJX79MbDBmNJtgLl/ncZjSeIMkinpfk\nxMe94qIok8sa/MY/+C6+4wIiuWxxyZAkK4jYQicr8e2T54tt22SzMUC0Wi0EQcLxQhDijvbe9RWl\njIGpxJ0Gw+GQ/f1dRFFkOBxyenrKt771LR48eEgmm+X65pxf/fV/yKPHX5DOxiK60XjGndu3yGQy\njEYjPN/BNOIc8pSc4kc//hGTiYNh5vn5x19wfnbJxmad+WJG4IgogoQshMznE9565032bx1x8viC\ns+sztnd32N7dYmd7DVXyEaMF5VKeMPDQZCM+bHoethNnBqgpmccPHzHo9ihUN3D9iGK1ER/oDJPj\n42MMXSVjmIxGE2rVPGvrTUajETvbu/QHPaIo4ubyClVWQBSxXRdV0xkN+kSCiCypbG1tMbcsAtfj\n9/63f8b9+/fRVJX19TrT2YjFYsHe7i0kQea8fcbW1i7VSpOPP/qM/YNdLk+fEwY2f/Zv/4T//L/4\nLzk7O6FWa9Jut+M4ZULK5TKdwRDbnnN05zaBHyGKUtxXLoAoCJw8P2U2m7G9vcv1xSUHBwcUcnlU\nXcFyXJAV0uk0o143PjAEAZPREMMwkGUZy5rS7w85ODjAdeNrRKFQ4NGjRy9YQV0WC4v19fX4OizL\nWJbFaDqjubaOYaRRNQ3DMLg8P0USYtfJZDSiXC6jqiqTyZibdoedvX3CMGQwGGAYBv1+n2q1Sq1W\n4/T0lEIhh66b9Pt9RqMR2XyedDodX8Mch06nQzadodfrMRmO0HWdW7ducXNzw2AwoNGI/9aXN5fI\nqsLa2hrTucVbv/qf/Y184PL/903+/38bDIf0+n0yZpbZbEorikgbJuPxGEFUGQwtnj49QVNUxsMR\npWqB4+OnXF+dcXR0RC6XW32v64trUpqMH0Gn1wZJZm9/H1FOUW+uMZnM6Pd75LIG+UwMWI8fP6ZQ\nLvL1b77L5uYm+VKRaqnM2elzfvbhT9nc2ialGMiBRC4b+0h3dnbwPZdKscCg3yclSvSnE9LZDLZl\n06jVSKVU3MWczmRIq33JW/ffprm2ha7rPH34GFmQcL0FZ1dtams+teYm/fEUM53GDSI0XSeXT7O/\nv41pGLRbLSQpTplyXZ/TszPu3LnD6fUZINLv93n29JRM1sQwDPKlOh9++AFrm02Obu8xGPVJZ03G\n4ynWwmE8niBKCl4QESLgI5IplPA8D9f9qmEpAVdZluO0r8gnCLylBUxD12Nvb+h7iERIAqQUeRXk\nMZ/NiIIAIYqYL32oCRAnqV3JxJ7souPCinjfbVkWqqp+VbEoK4R+HLSTWLUSS1Kw7KT2vHiVEEUR\ns9lstZtORGNxo9VsdT9eTG0bDoerSSA5YLx4Hz3HIZfLrQ4MQhShp1KrxiVZlld0vyRJuH5slUse\nh2QPL0QRkiDEtqkgBlVVVUGMxV9mSiUVWgBkilXuNPJMFnOUlEIYxZnrth8ymYzwXBfT1Dk6ukUu\nm2Frc53FIq5aDJe28MXcxXMcBCRcN6DT7kIUIUrxZWA6nfHPf/8PYk2Aoq5YiKR0xHXjQ5sfBqRU\nnfl8SiSIqCmTIJRYWDbdsxNm0zmWtcB1Anw/ZLFwlgckafU3TaXii1hMWco4tsXUmhMCzXoVw8zS\n7nY53NtFk1U2twoMR3EHt26k+fo771KsNDk4EukN+iCn+PFPPuBrb90jEnyu2y1kFR49uSEMr1gs\nFhD6iFJEPp/nZx/+nIcPnzC3XTTd5Ld/53d4fvovuTyP44Ibmxm+9yu/zPe+802eHT9hd28Py3b4\ne9+6z3wx5vzymkKhQKmQ4eTpU4r5PL3rEaIiUyhoZLImoWWjpnSePHmCllLY39nhVFJpbmwwtz2U\nVJzHcH19Tc7UKVVLzMYzfM9hPBxQzGfIZDL88Ic/5OVXX2EynTK3HabejHq9xnxuIUUqH37wPvuH\nR7z+xj1m1gTCCEGW+PXf+A02NprM53FQVX844uDggHy+yNnZCWvNJrIo4NsWpibR67YIAg9rbvEf\n/qN/zPn5KbqmMRi2OTjY5dGjp0iKgp5Jk3NdysUsoe9BJJFSFdKahuc5jEYjdCOuaHYcjygKePT4\nAa+98iqZTIH+aEYYga6IpCSB4XDE1JpTyMXxxtPplGq1Sr8/XB70ZbzQ5/L6mlKlwmg0opLLgRDR\nuYmp9US/ksvlEJU4/Gg8tdCXHQCyqtGo1ZiMhnHrpaLQHfQoFAqkrTn5fB7LsjBNE8dxKBaL6LrO\n1dUFqZRCt9vl4CBPEMTi2sViQbvdZq3RQJIkisUiVxeXlMtl8vk8mUwGUZExMmnmjk2uWOLs7AwE\nhdFwxsa6SqOS/xtj598KAHcdB3uxoFFrIi33m7a7YDge0G47DIcWresbdrbWKJfyaKbBN7/5DR59\n+SVe4IMosLW+hSrLPD95hueGpGSF+2++y3A8Ze4tsB2PTz/9nFIhy2IxpFY9otNqIysi3/3ud4kk\nET8K0XOZ2Ne3mJE2NCrFAjcXl2iSQTFXQtJE0oYGRAReLJ6QwhB7PifwFjgzAVFWEAFZlBhOh+xu\nb6GpImvNDf7qr95jMhuxt7OPa/ucXR5zePc+dihgWQ6Pn51SKpUoVcpUamXGkyG+t+D4+IpSqYIs\nqXzy8RexUEqR+fDDjwjceMpVlRjgiERGoxFnT9q0211efvllRqMB5XKBIAw4P7skV6oQihKSoiIr\nAmnDJEJkMrXwl9PgbDZbeXYlWcT17OV0Gi7B6auELUmSCJblGwngT6fTVThJIjpLpVIrn3YYhqTT\n6bjO8YUdtSRJqwk3DEPS2SwAtm0jizF9ney5F9YcOZViNpkiq0o8xXouqqqyWCxWNPiLTWMv7r2T\nPO7kgPJVLam3KttI/MyWZa26rGUxzv8OJWkF/sn9SuxfyUSdTqeZWhbqcsJPdu/JY6VpMaMjCALK\nsv87k8kQRQG6FFPzXigwnY3xohDHd1EkKQ5YCUNyuSzr6+t0Oi3Ozs/JZdNMJn3m1jTWVegGGTOD\n5/qEoYCkpXj89CmdzpDD19+mvn0U/wzXJRR0dFPDDfxlhGhs3en1xyshoRvCbL5AQkKUM/z5Dz/g\n+fNTXCdkPB2QFMp4nocix8JFWRG/0kJI8YriweMnX2kUPIcwWtrr7DmVQg41DHnw2RdUSlUEKWIy\nHRDgc3h4iCSqq2jT0WjE+nqdH/zr/5PPvviM6WLIfG5jLwJy2QKz2TyOp1VERClCFKT4PioqGUNj\nMhkxmXV455uv8fDjB5SLdb7za+/w93/p6/Rap6Q1kYdffMpkZlGvleK/jWtxfdbHGefZWWsgiiId\nZ4gYwXA8wQ8jxuMxo1E89Yaug6HGE/Jsqa7uDYYUclk21us8e/aMwbDHwe4B1mzGzs4mi4WFkcnG\nB1gtjT+aIC21N449p1rKc3Nzw/Z2g0LOJKUqTMcTyuUqlrWg2x+CAnvbB0SiQN4psbG1DaGAqqvM\nxlMWwoxxv0+jUWRmLbCEgEzGpNVus7u1zWQy4uT8GVEQ0lzf5PnJGZEwwbXnEKXQiirDwRjXWmDN\np8sc8RAhDPijH/wrvv2dv8dN65JXXr5NqZjm2ZMHDKcWlUaTxUzEndukTZ2UbuAvUxlzuRyu61Kv\n13Fdj2q9xPXNFbKsMLcXpHQNazHH0PTlak7H8zzOz88pFsuUKlVEUcZIZ0ipiRAuaT0bUK3X4tXD\nbEa5UqG5vobnuMwm09VB3zDisKl2+2a1chsOY1a4WCzGOpYoYjgcrg7qQRTSHw7IF4sIisz5dRzs\ns7G1yWg85vqmTa1Wo17PcnJyxsHBwd8YO/9WAPi4O6WQzuMtbPKZPK7t4fsLhMhF12SG3RZff/sN\n8tkMG2s1fM/Gcyesb9QYjUY015p47pS55SHLoKoa5UqF04tTHM9lOJ5yenKBaZqk02nefvtrzCdj\nVElG0+OLaNowmVozRr0xw2Fsayils2hGBtON06h6oxtEN8Xt20fMrAmt81iRfnVxgufbVJtrXHUv\naDSaFMprjEcW+UKdh49OaW5v8ekXX/KDf/MnFAolMvkGUQR3X/8lvEAgldYJPJ+3336HbDZNu9Xi\n47/+OKZs53NcO0AR0iiKj6boZAtZLGtGuVjGsT3mi3jKfOONN5hMBxSLRYRbEpmHKYy8hiln6Y1G\nzJ05gSqzcB38MEBCIJIkZCVFr9dD1zQCQWA6na4m5FgMltiwwtU0bBgGkR9gGPGLxFlS6vEE765o\n7GQ6fjHpLNl5R1GspVY0bTWdJxGm0+k03g8vX9hRFOEEcdFNGIYxGBvxizgkWmWIS6GEpCgYhrEC\n6PlyVZJOp1e79UR9rmna6qCSxJnqur4C/H83rrVarTKdTld7+RfV8Mn3TlTwyaHAd2PQffHgsGok\nCwIkYZnStoi9paEQICkqopIFF0RRIEIkrWpMJ1NUWcUTIva2GjRqFU7Ozgkjie2tXfL5NK69QNPS\nZDMZ5nObjz/6DD/02d7eZdodMugN2Dp8mfWDlwG4evaQj//8j/B8h9AOCHz3hbx3Bcf2EMX4d/R8\nG0MzcRcWz758xINPA3RVR5VTCJKCJAtIkkgmqyHLIlEUK/AzmQxm2iCbza4e54SlyZhpsqUck9kY\nTVV48vkDJr0BpmlydnGKLQrUqxU0VeHpk1MMTUVPqZiGQU5P4c0tfvu3fo0nz56y3linVCoREBH4\nAhnDRJFFyuUyrh9rH3K5HA8ePkVCYHunyfPnX1IyDOrfeI1XX7lFMZfm6ZefcXl5yWQy4Tvf+Q6u\na+M6C3a27iBEJ1RKBXrtc6JowXhi4QcunqfQWItrRoMgoNcbkDGz7B3s0u/1mHS7TK0AP4B0Ok1q\nWZZzdOc2jx8+IfQDCjkTQRCZWjbTkzNqtRpPnn7JZnMbKRIZdtuk1AaD4YyDwyOK9SqO4/HpZ59R\nLlf46c8+oNFYo1EpU200sF2bMPSp15pxtHEYtwqeHD9fMUy1Wh1TF1HqCoHn8+DBA+4eHeI5CoH/\nt3MJAAAgAElEQVTtM+p18X2fV1865Gcff4JnzyipJUw9jbmW5uz8HFGSsB0HzdAxzAy5YolnT54y\nHI5ptbsEUYggqVSrGdrXbQpHBRRNIptNMxz1SefzHJ+c8Oabb3J9fY0YxOJTx3Op1mpEEcsK0izH\nx8dMpHG8htJUtre3CYKATqfH9t5uLCCezymXi/RaE4q1Gq1OhyAS4ta5ToeFtUDT9JVAzQtcxChm\nMgeDwfIaQRzg5fqrFZ8gCFxeXnLr1hE//elPOTg8BGL766DXp95sokgSF2dntK6vqVdrZLJ5XNem\n2axzcXGBrqd49uwJ+2//zbDzbwWAW+MRvu+xmE5w0nNMM8tas8G9N15CJKJ1fc3t24dk0gZnp8eU\n8rnVSci24xO453lYloW9cCmVSnz00SdkslkG4xG7u/vYi1ipvL6+jmkY2LPYPlApV5nOLU7OztEM\ng3a7TXO9wf7+PmfHz+PYSyGO9dzc2AZRQFdUWsMx1njAp59+ymQy4p1vvkujuUY2l2fhevz1R5+w\ntb2Prshctdu0xzN6vR6//r3fpLG2Sa5QJAolECSms/Fquut0OnieFwspzMzqY88NePbsGYeHh1Qq\nFfzIp1yucH19zbe++cucnZ9QLpeQpDjGT1EkXNfn/ltfYzyeMlvY9HoDHM9DNzK4UkhKz8UUuufT\nHw0B6Ha7qwsrsKKDFwsXVVVW1LYsSwSBHyc7jccrUJrP56s9b+JtfjF9K6GrE/D6d8NbwjBkOp0S\nRRGFQmGV1LVYLFYK1YVjLxPyQlzfQ1LitDHXdXHnFrlcjqll4bvuCkhf9JgnfvJErJZM2UmASwK6\nL5aeJBN5EARYlrUCbMuySKfTuK67uhgmqvd0Os1sNlsdEpKTfNLOlShkF4sFpmmu1OxB6AGxyM1a\niuNEIcJxFnRaV6yvbRAGIV7o8/W3v85f/ug92q0W5XIJezFnRkC1VgVAUVXarR6TqUVIRG8wYjQa\nI6s6m0evA/Bn/8f/xPmXH8c7awHCIECRk5x6BQEJ01RhqTcoFytIRKQrZWRZ5NbR3oq1IRJJZwx0\nXQPCGLQT5a5hxD3Uy8cH4gtyGIbMZzPklMzCs8H3uX72nN/9p/+EjbVNJpMJ7ZsufuCgGSn29nZ4\nfnq8Eh/WqhXq9Sqev+Ddb77DsD/CdV2azTopXePq6opysRQ/fp0O640qURRRy+vk83leuntIragx\nmwxQRZnJZMBocI2u6/T7XWq1BovFguFwzN27d+m2rwl9lz/543+FLPjUqjkm0xGD0Yzd/dt0Oho7\nO3vc3Nzguj62Pac/aNPt3ZAv1ekNupiZTJzk5Xvs7e3TarXQ9RQLa0oQ+LTbLfS0yeXlJePJhPXt\nXUbTGcV8ke3dA6II/DDgg5/+lEw+w87OHqKk0un0yOeLpFSd0HNiKlcCazaJGwWHQ7Y21hiNhuim\nzrPPn9FoNGh1WjSWYP/+T37M/fv3mdsLFo5DqVSK0xJdh8uzU+7eOuCTzz4mDEOGo3jfWy6XefTo\nEWtra9hOxHRi4QYhmqHzne98ByEMmFtTCqUiipLC8+KD7nweC0TDIB6S9nd3OT89pVKpMOj1GU2G\n5AoFIML3E3eJwPb2JoN+D5EIZzlkaJrG0dEtVEnEzMYukOGgh6KCSEA2l2Y87NPptCgUSsxmc26u\nu2xubpJK6eTz8WG/33/CS3dfwbKm5HIZfN8nm01j2/ZKJNtsrq8CiizLIvR9ut1urL4fDlEkiXK5\n/JUdzvcol0p4rk0mHQ8g1Urpb4ydfytU6E8++cn3ZTHk7u1bHOztYOgqL9894nu//itsrNXZXKsz\nHnTJpXU21xsU8jmen5xSKBTI5XIrkVW9vkauUOL5yXlMVaytUavV0XSDw6MjtFSKcqlEu3WD77kM\nh0PCEBQ1xWw2p1Zfo9FYY2trl0G/z6g/WGbmCuRzWQQEPv38Y7rdDs16g4U1olwuUW9ucOfua0yn\nC65uejx6fEyp2qTXH3Nyfk2juYGiqBzeeYlMroysmTheRK5Y4osHD9BVhcePHnHn9h1OT09RVQ1J\nkslkc0xnFvVqgwiw5jOurq+oN+tEy32ypptkc2lqtRqe6zIcDlBTChcX51ze3HB9c0OxUuWLR08J\nQtA0A10zcHwXP4gIvABBlJZpaS5BGOIsVdeJ3UnTVFRVQdPjf6u1CjNriiwrsQ8ynf4Fb3ciHEuA\nMhFzvUivA7/QKJakjyW7rEwmg23bqylWluVVxKkkSaS0FP4yJEWSZVgeEFYWrSVAA78A1skLMAHm\nJDXMXYJ9cuAQBCGm95efSw4ayffSdR3LslbPv4RxSGh74BdqQ18sRElYgReT5BI2QFEUPNdBFMAL\nYOaJ2FIez1nQOnnCybNTDvYPWDgeSCphBP/2z35IsVhElhVOT0+wZhaTyYzAD3Fdm4urG4bTGZKs\nIooyvh+wdfcN8pU618cP+fjf/Mvl9CygyAqSKCEpUqzezmTiggsjRRC6fPdXfpnf+a3f4GB3k/v3\nX+G11+6wvddge2eNzfUK+7d2yeY0SuUsuXyaXN5EECIiQjJZE9e1ubm5Igx9XNemP+hjGDr2bMJ0\nNo4jdV0bJQp5+96bfP7JR9jzGe++dh/Ptghdm27rBiGK2GjW2d/bQVNlnj5+SK1WYTgYLJ8jIoVC\nDkGM6PU6WNYUPaWwvbWNNZtyenKCNeny9MmX2HMLSRBYWBNsZ4JnO0xnC3K5PLIioygq6XR62Q/t\ncXx6gqjEcbetmxs+/exTMtkcL736KuVqDc8XmEzGK6fEfG5RLZdYzC3mlk26UOLo6DbnZ2e0b26Q\nRJGnjx8ThgGCAIIQIYoCV9dXrK+v8eXDB9y7/xaeFxJFAov5nMura65vbmh1rplMpmxt7fDxJ5/R\n7/d56aWX0DUDPwhRtRS+F3D87ClhENDvdXHsObIsMpyMUFIKpUqBuW1hzWcsbJvN7W28wGdzc43z\n01OqlRJrtRo3V5cErkMxn8f1PZ48fYIoq0RAp9ulUavHRT+eSzabYzKdcf/+1xiPRqiyjDWb4jgx\no9VoNBEEgdnMIpeLy2V0zWBuWaQ0jZSiMh6P4+rXcpnOsoxKURTOz8+pVCqoikK33aLT6YAQEkYB\nmWyaTz75lEw2Q7PZZDIec3N9QRTCfGFjmhl63SGqqiNLKtlsjkKhyPnZOYV8EWs2Z21tnUwmw3AU\n79ar1epq8CgWi0ynU0wzZvLS6TTe8vogSdJK+HZ+fh6LDFMpJFHk+vKKSrHIoN/l5PkxD798QCGf\nY++Vb/3dt5HZw/PvF0sZtrbWKBdzpE2dre0GP/vwJwz6XVx7TjZj4MznzKZTLi4v2djeQ4hEokgg\nnyuSzuVwXJdmc42Dw0OE5dQcAb1ej+k07utVFYX53EJbnqJSKR0Q2d7ZBTEGkCgQmEynbK6v4zgu\nmqotvYYDMvm4OajVusY0Y7WkkckzmbhcXLTo9SZsbuzT7gxQVBPHCUlnCuiGSbnSYG1rl1p9jWKx\nTKt1Q9ZMU8gZFAsFHCeOj63VqrRabfrdPqZh8sUXX1CrV2k0GxweHZLLZpEkiXw+T7PZ4A//8A9p\nNBoMhwO63Q7Hz59RLlcYTufIqoakaiw8H9fxkBUlrvgTFaQAVEHBtuZEkUAUhasJNKGCNU0lDAM0\nXSWTMdG0FLIcX9yNZZKW58WCsMSulUzUCRgmO98E2JLbwf/L3Zv9SJZn932fu2+x75F7ZlXX1l3d\nPd3TM2MOyRkuIkWaBjf5QZYNG/4HDD0a8MPAMGC/6UGADEOGYVgmBAECRNqyIErD2agZzkz3THdX\n116ZWblGZux7xN2vH278orMJwy960TCBQiWQGRkRN+6955zv+S58gY0uiqnYUQNks9m1P3kURSDL\naeFeLFJHo1VB9XyfTDaLoetr9rgojKI43gw0EbtqsRsX07Lo5MW07Hne+rn/uqEMsJ7Ixd4c0sIt\n9vc389RF0b4ZXbqW22UySJCSZOL0+C1cH9UpMSfDZNTn4vAp4Yqo4wch1UaD//Of/jNMy2E2nzGe\nTlA1jXy+yMbm1gpdWXJ5dU0Qpl70SArZYplbb39AkiR875/9r/iei6KpKIqKvuIRKKqcWkwqMoah\n4gdz3nzrDr/+m7/KfNSmXM6gSBGL+QTfD4jDiPlsih8siKMAVZHw3AVR6BOHIRnHWXNdshknNfWJ\nQpI4Io5C5tMZpqnjRy75rM3xq1fc2tlm0O/hLeYEcYQXLJGlBE2T8f051UqJ6XjIk88+QZETFosp\n/X4/DdPxXS5bl7RaLfb390mSiFzOoZDLomkKEjFv3N1jb3+fvb0DBsMp5WoZdzmh1tijVtng+qrL\n+x98QKlUXHEydBzHYu5HVGoNLDtLuzegWKnx1sP32Ni+RSzpzBdDSODi4pJMJocsqziWxWw6o76x\nQaWxQbfXo3XV4j/5vd/l1YsX2JbDgzfvoSqfN7cvX73i9u075HJ5+sMBsqQyHo9IoghV1qhWy3Q6\nabKgk8myt7eLoogsgATP83ny7Gm6SkLC0DUkCYajIYauoxkK9XqNwFvi2Ba+57K1uYm28lyXk5jJ\neEQShhwfHTIY9Gk0GrQuLzk8OWFrcxNVNzm7OEfXdHwvnfgzmWxqK6zpXF9fpysT10VTNE7PTlgu\nlxSKaSE0zTSq0/d9JGTsjJM24klqd1Ov11F1DduxKZfLK9dChfb19YrQaDGbTomimMAPAYnNzU0M\nTScMfCQZ5ETBsR2m0zmeG1AqpUS45cJD01VKpdJq8FGZL2aYq6an22tzcXFBsVhcN/uLhUupVGY+\nT8mlKXFVI4pS/4sg8NF1g9FoxGSaRomWinm2t7aIw4A3bt+iVq2iyDK9bpd3f/n3fvEL+D/6B//9\nt/r9Pq3WBa+Pj8jnswRBSjzY3d3FWy6ZTsZkbIfecIBuWLxx7z5bW/u0O11m8znu0qW50cQPQyzL\nJAojWtetNbNYUVRMQyfwvRRqlqV0ggwjlq5LAoxHI8bDEUkcks/bFLIO3etrkshnMh7QH3bYP9hP\nT7AgZDkZQJxgm1kuTq/45OPPAIkgSjh6/XqddV0olgmikPFsgZPJrew4fQh9bE3BXS6QkoTpZMp0\nNuWjn35EFAaUS2XqtRqZXAbLMti/tc9kPKbX767iUVWatSaOZZOQOnR1uz3iCN588018NII4YeEF\nTGYzSsUSmpoWT0vV8f0onY5Vndl0nE4bqkqSpBC549jrQlgqFVFWWd1JHCOR6qNTQ5aUhSkmUUFa\nE4VKFGThjCSmaGHAIiZVMaUKAxbR1UZR9LlhzIpBnsr1JJyMk2ryvfR54yRJ08xu2LEKa1XBGhfy\nLfGzbDa7joa8OWkHQbC2Y/U8by1xWRPZVt+LhkA0JkLPLqZt0SxYlrWWshmGwWKxWKVipZ9f4PtE\nUYyUgKopRImEZTuM4gySpPD66SMWSxdNN8gXilxfd7EcC1mCQi5LvVqmWiljmyamrmNoGsVShsl0\nQX84JkliGru3uPv+15EVlcOP/4rXjz5C03VkRUnduTQdWVFR1dTlLT1OMdPZmF/9la+TcRxif8F0\nPCJOQnRNY770MU2LJJbwgxDHzq5WITNkOW2IwjBYfb4RcRytGO1ByqRW1JQdbOj4oU8u4/Dpz39O\no1ylWiml3IGMhh8v6Y97HNw7oLHVZBm4aJaOaRg0NurEcUyzuUGtWiGXydCs1ygVc4wGPSQiQndJ\n6/Ur5rMRuiYRhi4SCWEk8fbb73JxcYFtGjh2gW6nk0K87oLpdEK/3+fu3VQWNJrMeeON27ieR7FY\n4Stf+SqWmeH7f/lDcoUKo0GXdrtNsVhic3ML2zaxTYPxeIhpOUiqzrNnTxmPh2QzGXRVodvrUqvX\nGI+mhFFEqVRm/+BW6sXtuuSyWWbTCXEUEMcBmpqmYBWyNvlCDmSJTz95xMOHb+F5Lo1Gg9OTE1RN\nR5Flut0uvutSyOewbQvbMsllHWbTKVnHIZfN4tg2GSdNfVSQefb0MaaukS/kGI8nRHFMrZ4akPRH\nE0zTQtJUptMp+3sHxGGMrqcxwmEY4/re5410GKJqKrbtEMfJWvoVhmFq7yxJOLk848mEi6sWzWaT\nJEkoV8rM3SVRlLBYzHHdJbKUGgFNpxPKhTJRFFMuV7m6uqZYLKHrBoqiYlkms+kUWVZotzvomoqu\nasgKbG40SJKITNbiut0il3foXF/juUvKpRIX5+eUilV8z8cyLRzbIZvJcn52hmlYVCq1NE9jOCQM\nA3zXY7lYrOyhk9SqNZulXkt/zzIt7FWSniDJ6brOwTt/Aybwf/QP/sdvNTe2eH18hqKkN72z0/OU\nSehYbGxtkXEyWE4GVdMp1+rEwGzqpsYXgU+5VAQpzT2OwtSNR17FuhWLxTREIYp588EDqtUKtq2j\nqQYvX77i8OiI+WzG06efUa2W2NvbQNfg5z/9ITubDc7PXnPROuPu/TsMu0MGvR7NapXhdZt6uYqG\nRuvigpk75Xd+93fY29+j2azz5oO7+GFAtpijUq3RbG7QbGzwj//x/8Kf/B//O/t7W5wdH6NpBmdn\n5+nU6nl88OUP+OrXvobnuVxdtag3agzHI66urnj85DG6kcYsFgsFoiBM987ZLINBSl7b2d3j/PyS\nSLVAStmRiqLgZNM9zng6YplE+CS4UUCMRBJHGLpKsipeMhKGriMBpmlgGjqO7TCbzXHdlSlLkqzl\nZsvlcm0VKoqW2GkLlrr4uumYJibzm9PtcrnE9/21pvrmrpxVUxBFEdpqT69p2gr699auS4IwJyZw\nAdGLomqa5hra7/f7aymaKPpiJw6QSBK246Tnmp+uGVzPI1z5uIt0MVlR0A2DYOX4JF6n0K2Lrl1o\nxE3TXEPv09lsbS0ZRiGWZac7PxmGcTZFUlSZTLHIwd076LaJqsk0a3V2tjbYqJcp5bNkbZt6tUwc\nB9imjqppjKdTeoMRd9//JfYfvIcsK5w++5if/Kt/jkSCqmtp+qgsI8kACUkso6rpTluVVZq1On/r\nN36D+WSOtbKItC0bkDCtDFEcoakylpUhjiGMYgzDWn2uCr7vkc8X1nwGYyW7Sxm9EZblMJ5PqDfr\nDHoDIt9ns9lMi04uT6mQRyHm7hu3ub5u0WzUkVWVRrNJpdmgUq1hGQa2aTMeDLF1k9DzyNg6gbdg\nOh7QOj3mzv4uhqbg+y7z5Rx34XH48gjbsnHdOd/7zneQY4mtnTpxHLB05/R6Xfb29ikUygwHMyxL\nplatMOoPyGYcnj15gqmnx6TbTk2QatUasiwhSTGSHPPjH/2AW7d2QFap1uu4yyWFXAbPndPptrFM\nHd2wmIynJCSrYxZQq9ZYLJaEnpfKljY2cByb0XBOoVBk0O+iGArLpcvLF694/Pgxt27d4vj4iPli\njqppvHFwgLk6v8vVMpZpkiBhGCqaouJ5PjIylmlxfnaG5y5xsjZRGOBkMszmC5aej+U4xChcd3p8\n+YOvICsqtXqTQiE1KYlJJVumbeMF/vpclxOwbAdFUrAsE21FghUNtVCAmI5Dq9Mmm8+tbJcTDNPk\n9OyU+/cf8PTpExRZhijEc11WkBKyrHDVavPG7Tv0et0VahcQBGmMdKVaZLmckc9l6Pfb2LaO585I\nktQ4KY5TS9XtjQ0G/R62ZRFHIYVimUqlynQ6Qdd1Li4uuHv3LhcX5ywWS4LQx7Fs+r0eSRTSvk69\n6gMvwA8CRsMR2UwGCSklqZIwn814/vw5kpSiC403vvyLb+TyP/23/3ViGAbT0ZjO9SXvv/c2mUwm\nPTFcby03GgwGXF5ecu/ePa6uLkG2mM0mVMpFTNNA11JYud1q8/HHP0MzNWw7Q75Q4sG9B3heqq/c\n3GjQujhBkQ1qtRqdTodszqJcLPKzn3/I1vYe/W4XE/j4w4/Z2t3FKmS5GnT52nvvcnL2OjV7WMZc\ntVp86Z03mbszSLL0xwuevjril7/xTULPpVzfYBFElAsWpVKNJIJ2+4p792/z5MlnlEubPHv6fB2A\nMZlMCKNgDe3atsne3gFIEpl8nvF4zP7OLqevU43m3bu3efr8Bbphcnh8Qr5YWhkryIx8n4zjrM0v\nkiTBDyKWyyVZSyeKknWhrNQrxHFEQkQxlycM4/UUrak6i2Vq7Skhr/fWURyujV7E9Cn2vTflWzfT\ntcQknsqkkrXcSxR8ATWLXbZ4XBiGq8Q4I/UgXv38pl2qIMrZq8IoIHnxN28Gh4gccNFgiAbBNE1G\nk8kaSXBdl3K5vJaJiWbjJpHN8zxc16VQKKzRAbEKEEVcURSU1Y5fvBZhEJM2PAGaZrBcuCl7X0rW\nzPSB8wbT2Pr/vYaSJEFaWVVC2iRJq//jBKIYZFUjjkIOf/odXn38XQxZZekHxKvPIY5jNFVOP09j\nZXhiGGRME2s1veiqwt2372GbKlHsI6EiKTaKIqU+AHL6+NFoRDabJZ/Pr93zMk6W5XKZQrpyChN3\nOp1UrmfYLEMf13dxZ3PUMGKnVqNWLHLZuqBcr9FpX9JoVlJeQhgwHA65/+ZDipkCz1485cHDByyX\nS7r9HnEcUSzl0XUVz0/PnWqpTP+8w3WnjVUoYOoSvcGYO3fu4IVL9nf3mA5HlIoG3XaPZrPOyckx\npVKJXC6X2oaW6zSaW7w8ekWpUqRYLHJ2cooUJ9jZDJKUsNnY5Lp9wdHhSzY3Nwn9AENRePnsOe+8\n95Bsrsx4PCUIPPr9PoVCgSfPn1GuNGg2myzddILt9Xqp3Gk65f79B2xtbZEr5vnJhz9GlirMxjOO\njp+x9LuoikEmk+Nv/+7vMRqNuHP7gOurDoqSIh+yqrCYuyyXS8rlMoZhYKoa4/GY0A+ZTaY0GnWQ\nYnKFLD/72Yf86jd/Lc0C74+YTGZUKlXcZXq/WLpz7t27x7OnL5C1VYBStUIUhVxft1EUhbfu3Wc+\nnTGZTHCyKZ/EW5HihsMBkiRRqZT47PGnbDSalDe3abVaKeLgZClmc6mUdYW2SSTMxiOury4BqFRq\nNBtbtK7auK7LxsYGURxgWSadzjWWbWCaJscnFxzs7nF8eEQ+l2E8HrO1tZWutAyJMIwZD1MELmNl\n6fX6NJubaKZFq3VBvpAFUsmYSNiLVRPHtOj3rgl9D1M3KBfTVEs7m2cxSw1m2u02V+1r2u02B28c\n8PLlS3Z3d3n27BmZTIb/5n/4J7/4Ri62Y7K7u0MSh1xd5sjmbNylx2g8Zj5dgiwxHgzJl4rcu3eP\n/rDH9XWLYrZGs1omImY6GaQ7O0J8b44sJWxvbpLNZjk5u2A6HnF5cYataciNEnEY4XkjunGA73l8\n+uo5xXKJfm9EHB/z6uUx9UKVt995F93QKDfrmLkss0mfnY0m/f6Q42GL3/it/5hHjx7xwx/+kL3b\nBwxmHk6ujKKa1Ct15u6cnOOQxBqKrNHutCiXizz+7Cmtiw5XFwMcx2I8dpESmdlsRqmcB2LmUygX\nq2xuNoljaLVaTEYjft7tksnYHB69IFfIMJ5MCeMpmmHiBRELd4mETKlWIQzjtY3pbJb6tmsSLP20\nyCq6lprUqCq26RAFqWwojoMbxXW5hpzDMCROUv/g5XK5jo0UBU3A52Lfq+v6Wvt9k7wmCG6i+IpQ\nD2BdSAWULZqMXC6XZpGvip9gcwsCmud5WCvvctHhi+ZBJI+JfbYISjBNcw3RW5aVThKrnbnYvQv/\ncmHlKgq/eJ+i+AvtupjkgTUETxwT32DjC4i/UCgwGo3QdZPBYLDa66XoQCKlO+jc4hTHqiCpBl6U\nEESQyBoRMmEiEyETSwpIKuKSTlb/AJBAlkHHJ+ef0Xxzgy/t/v6ap3DTrCUIU1lbHAnJXUC+kDLJ\nc47N6ekpuqGwXC5ZLpMUhVAiHCvDZOKv1QtbW1trbb+wrVVVFd3Q1p7SophbloW/9JEk0DQFTJWs\nbpPJ2Dz+7DOKxSL96y6LyZyBorK7t814NuVsfM7zJ0/Z37+FZTn85EcfUt9osnuwRxzHzKZjDk8v\nSeKIjGExGM4oNPcYLHxyuSyZbJ5CpcHSW6AqCdfXLaQkoa5XmUxPMawhzc0GuqExGg3TZisJWSym\nZG2LcOlx1H6JZVlUG1Wmk8kqijLg5fMXFIo5kiiidX6BlMhsbe6Sd2r8+Ac/ACkhk82i2SY//+wT\n3rh7BykCzVDpjftkjCz5bA5VViiUSzx5+gmj6ZiH777Pzt6bqJpDq9XCT24TxxsYhkbgzZmO+ziW\nzbNnz1L0sZxdN9GWZfD48Tlx4vPGvbtIkcrC98haNpVKZX19d7pDcvkynd6ISrXKYDSj2WzSbrdT\nR8XRgEqpzOujY6xM6opm2haTyYxqtUqxEhL5AQvfY75MrVU7nTSn3fM8pCShVMyvr6eMk8NxUta4\nnIA7m1PNFRiP+kwmk5TUmkuvE9syuLV/m/PLC1RNoz8ZkivniLo+hWIWSZLo9/tsbm4y6PcZ9gfo\nssTl5TmSnHB9ec2wP6DfG3LvwX1q1U0eP37McjmnWd8gCEP2Dvb5qx/9hCiK+JVf/TqXK9KlunIj\njKIACQl/EfPwwTtcX1+j6GlTX6w0sKyUFP3q6ITFdMFs7mEYDp3OgDjR+clPP8G2bXL5vyEs9O/9\n+T//VhwnKJJCxrE4PX4NsoxtOSx8j4QERVtFVoY+tmVQr5bZ3NjF9ZZcXF7gWAaB761YgR6lUhFN\nVVBXrF5FktlqbuC6qz2KkpDEEZ7vIssKw+GQ6WSKbWVQNY1isUCxmKVSLOF6Hl4coZoqrbMToijh\n9PwSw3R4dXzIbL7ECwK++Vt/mxiVr/xHv0KxUOTTTz7lxfMXbG/vUiqm7nHf+973uHXrNv1un3a7\nzd279/D9kH5vzIsXh+QLOTa3msymEx7cfzMtCKrK8dFrqpUKsiRTKpe4vm6j6Qaj2Yzrbhc3DEFR\nSGSZfL6IF4XE8edFdrFYrCVNxAlIqR95GARrX/QoDFJ42HXXtp+u664L8M1oTk3T1tnZkITGARsA\nACAASURBVDKpxc5YFEnhQy4K4M2/I4JDgHUBTi1t3fUeXBDABFs9juOV1/N03RxIkrSO/LQsKw0t\nWEHvwq5USNIEHC8mfyF3cxyHIAgYj8epWczKw/xmopj4ulm0BTteEN3Erl8gEMJ6Nlr5td9cFwgd\n+s3n0XWdfD6/LvLisTIxSjgjWfQxwgl5xYVpCzvoU2SMtbzC8a6x/A4FaYIyucAOuhx+9B1ul1T8\nziuU8RmOewX+AkVKyOccHMugVilTLhZwLJNyKU+zXqOYz2EZGqqcUCkVMEyN+WzK3Juj6irual0C\nrIx8jDUZURNucnzuKS9y2sXa5WaYjEBE4ihm6bu43pKMbfHi6VPc2Zxf+fovM5/P2dnZYblYMp/N\n6XY6vPel9ynmixy/PuGN27dRFYXAj9jY2OT18Snj4YQkTvAWPrf3Dtje2KCQLaW59e6MajnPdNIn\n9F2ytpW66WkqupLgLSZMxwOSOEDVJJI4platsXSXxAnM5ili1G636XQ6bG9vA6kPvucGdDptzs7O\n2Nxs0rq6Ip/PM5pMuX//TVzf4/HjT2nU67S7HTRDT4NCkoQwCFPb3ThmOpkgSQnHp0eUykX2tnew\nLZvnL15RrlT58Y9+RK1SZmd7k6vLCzabTba3tymXK7TbbfZ2DzAtA8uyV85hLkEQIkkylXIdGYUw\niTE0fe0zXq83UVUNSQbdMsisJuB+v08uk1m5o/UxTZPW5RW5Qh5FVVPHQ5J05zybYmipAZIiyZRL\nJQaDQXp8NI0gilZxswle4BImCYVcPl1vaQq2ZeK6c7rdayzTYNDrEUcRkpTmKei2QyTJ6JZNTGoK\nFPgeG80Ner3eWroahulgcXJ6tr5fXV5ccXL8mhcvX4Ik0dxoMl8s6HQ6vPnmW3grtG06ndFqXfHd\n736fVqtFEEaEYepP0e0MabXamIZOpVjhh//uR3z26BG6aaLrBtetNpVKjRfPXnBxfs7ldYsgDMjm\nC7h+wMN33qFcqeIulzx79oLf+eP/8hd/B3705MNv3b//gDAIaLUuadbrqKrOwvOJk4TpbEbC6gQI\nfDK2hbdc0huOuWpdksQhu9vbBL5PPuNgWya9dhtJgq2N1IOWKI3S29raxFu6KLJELmOSxCFh4Kdy\ng8trdrZ3yObytK7O2N9tEAU+FxfnvDx+Sad7RSmXRdM1dMPi48+esLmzy1e+/su8/9Wv0h3NMJ0c\ncSxjWTZ7Ozu889ZDDo+OuWpdYBoGG80mL1+8IEkS5vMlz5+/YDiY4jjZVKqSyfL06WPK5SL37t1n\nMpmiKDK9dpfQD1YXQIBmGGzu7DBZzMmXysTIKKqGYdmMZ1P8IMAybZYr324hi4qiiDDw0HQN206N\nbQxdR9PSpDBhbSosTYEvsLDF9yKEREyayuqx4qYtitJNI5Sbk6coygLivgmFixv9zUIoirqqpE2Z\n53mfp4CZ5jqlTLmRES6Kv2giHMdZT9TSyqxGBI4IRABIowT/moOcaGpEYyOakDVsb9tr2Hg6na5t\nXJMkQV+9hps+7jfJfplMZr0uEH4GN2NVw1XEqNCdimOhaRqypKyiECVC31sVIQlvPuOr738JhRhd\nTths1Cjlc2QcG0OVMHWNOPRR5ARdlbFMjcVswnw6RlNAIiaJAwJ/yWwxpVTOsXQXeN4SRVLX6Mhy\nuQTS1YBt2+vjIlAf8bkL3+jZbAZAbuWu5/t+ioxoBoquYVoWqizTaV2jJBKGpvH82TM0zeD87JRc\nLk+n3aFaqfGTn37I/u4+11ctMpbN2etTup0eJ69P2NrYZDQY42gGh89fstFo8sMf/ZAg9Njf3UxJ\nbN6QjUaFrUYdb75g3O+xt92g22mxt7sNRBTzWbq9zuqcBNO2CQP49rf/gnv37t4gRgZpiEi9waNH\nn5HNOVxetTBMi4vWNb/yq7/Gy6PX/OjHPySfz2OYBrlCDt93qdfqhFGEHwbIikycgK6pdLptNjc3\nuO5cY5s2y8USx7K5fes2n37yKZau4VgmP/3woxWTOyWvKYpCPl8gm80wmUzJZQvomo7nBSwWLrVa\ng9lsQS5XQDdM5vMFjpOlPxzhei71RoP5Kjv79OKcZqOZKg2iCJk0XS9fyLO7u0u4klIZq2swDMN0\ngCqWKKwMe6bT6VpNEpEgyRKT8QjXXaIbJt4ybdq7vSt0Veb05DWFXI69nR0+/fQTvvrBl7lunfPG\nnbugqMy9ACebI1/IMx4OsHVtJeucIUnp9Z/60LsMRkO2NrcZjcYYus7x8Wtu3b7NwcEtzs7PSUj4\n0pe+RLvdZmd3h+XCpd/vUy5VsG2H8/MLWlcdcrkCgZdgmQ7d7oBsxuLk+IR+t893v/cDrtpdmhs7\n7B/cIvJC3OWSIPBZLJfkCgV00+Tg9j0ePf6M8WTKyekF5VKdb/7OH/3iF/DXzz761qNHj7hoXSAl\nUMjlGQ7HjEYTarXqWp6Q3thU2lfXxFFAt9sl49g0qkU0WVqlcs1wbIvA9zA0Dddbcn11zf7eAVIC\njx59SsZxuLq6xvcXfPbZp7SvW3Q6bfK5PPfu3aVWr3Hy+pjtzRqL+ZRW64L7Dx5QKBZ56+4Bo9EI\nWVWoNLao1JrEicTVdYdytU4YRGxtbTGfThj00+6xP+gThgGtVovZbIbneeztHWAYBqPhFNO06Pd7\nPHz4Fq3WBXfvvsF8Nl9NpgaKpnFxecmnn31GpVpne3eX3mjEeDZj6XnIigaySoLE0nNR5JRdH/j+\n2mgkCIKVjjok62Qo5gt4Kyaw49iEno+ipkVDMKPFjlk8VhTGmxOomIRFQRcyLOF5DWkRchxnDU0r\nioJlWevi7bru+m8Da3haMLchZagLD/Nw1UykxYPP9bYrhOEmXC8mPiHzurkrX99wVkEwomhGYUg2\nk4GVnEVEjIrmRRTem/vzmxatN61Y/dXkORwO1+9DwPqGYazPB8G6FwVeoAS2ba+PrYgoTZKEbDa7\nSjZLIeibtq/pbrGy/tuKkq5mNFVNfeyTGN0wkBQZzdAJo4hEgiiO0920ruEtl5imgawpacJdGOC5\nLhKgacba1CJFUdLPSjRkogkTn6VAWoTxjWhUfN9nc3OT4XCIpmq0e11kReHVq0OuLi549+FDNFVB\n11VmiznZQo5CPk+5UkJWUrTm1v4Bw9GIbrtLGMYYpkGxXEphV9tClhKazTr9QY98McfDt+8S+HOu\nzo8hWLC71SSXseldX6IqEEapFvvk9IJnz56lqhfd4PXr05Slbjvk8yXu3bvHt7/9FxiGiSTJfOc7\n3+HOnTs4GQdFVcjn8+zs7NAfjqhU67z3wVf5/vd+wNbWJrquommr5gaJdq9LrVFPzVLimGKhxHS+\nZDSeUKs3kFAZ9ccc3LqNrpmcX1xydXnFeDymmM/z048+YrGY8vVf/iUuLs6wLJvpdMJsNsFdBqnP\neKnEfLEESSaTzdO6ukZRDQLfJ5cvYBomo9GERrOJrCrEccRgPFpxSixIwFssGQ7GlItlRuMJczdV\nUfT7fQrFPLIs0Wq1cOz0+f0gxNB1xtMp/cEAy84gyXB0dMhkNKJarZBECe12G3t1nc8ms1TypqX7\neU3TMHSdMAxSiZy3IsfpKqaqYqgq5WKROEl49fIlmUzqYreYzem0O8yn8zW3JgwCMtks9VodWU3v\nU/sHB+t7RSaT4fzigsV8jh94tLs9lu6Sg/3bXJy3uH//AZ1Ol1brir2dDZIE4ihha2ePxsYOTraQ\nonG6Rn8w5M6dO/iez+n5Oblcge2tTf7iu99mf/+Ab3zjm5xfXPIrv/X7v/gF/F/80//tW93BgIzt\nUKtVef70Ce12B9fzcBdLppMpd+7e4/jomGKhSCaXRVFk6tUyeztbZGybbucaOY4p5vPMJxOur1rs\n39pnNp1QKlVQZJnnz1/wyScfM5/NiOMEiYTHTx5RyKd6akmCcrWcRkRqGpubDVx/we7+Dptbu8SR\nyvHhIyRZIYwTFl5MnChEUUyvN8Cdu2xtNEmiCM9d0ut2CaOQUqlIvVqlVq/z4YcfUlwFhkynMxqN\nJqVynp2dLY6OXlGrVel02oRhxOHhET/72c/xw4AwiikUy+we3Obk/JxlEKAaBlEEJDJRkhDHIEsK\nYRSlQTCwZnWLImuaBsYK4pQlCU1RKZSKhKH/BXj8ZgEW06GYuEVRFdKuOI7XDmw3IdK1telKhiUu\nFGEfKvbbmUxmHdkpyHxid3ozIlTsli3TRJFlDF1PGdFRtCos2vqcEs8piqRADW46rondt0ARgDU6\nEEVRug+PInzPo9fvMxwO0+MQpixYVVGIozTa0DJNkjhmOpvhLhaoSmqOIyBigSoYhrEm/InP5Sbi\nkM1mAdZF/KY/u2hsxHuLoojFYo6TcZjOpsRJamDiBz6e5wIJxDGymhrfqLqO66fTSxDFBH6QSimj\nNPJTN0yiKMH1PVRdZ+G6JEi4Xshi4WLbGXwvXDdMAi53Xe8LjHuBpgDr93Yz8/0mYVH47ZOAZhp4\nXogiy9SKFYrZHN32FfVmHUVTyeYzmI5FlMTMZjPu3H4DJ5NGNRaKRXa2t3hx9JJms8Z0OubNt++T\nyDGZfIalv6DerHJ6dkjozZCJ0KSYZ48fE/oeuXyG3f09/uqnn/L+B19Htxwy+SL5YpnDo2MMw2I2\nW9Lt9piM5xwc3KJSqbCx0WRjYwPLstaEWM002NjeRlYVVEXnnXfe5fDlIRv1Dba3N0iimHqjget7\nXHc6qEYqe5pOpzx69IiLi0ucTB7PC9E1i1u37nLV7pAvFJnOFzx7+oLhcMitW7f43ve/z9/9z/4u\nJyevuXf/jTR/un2NYegkSUy5WsfzUh6Roir4gY8fpIqJYrGUIhqdLpKsICsKiqqlMZr+kihMmM8X\n2JbN6+PXaHJ6fRmGgRv6KIqK57lk8zmGwxGTyYTlckkYRlSrNS5bLbL5HJ4fMp3N0vjP2Yxhr0ex\nkOfi/JxGvUG/18NdLJEkmX5/wJ07d2GVrtZopPavumbiuz62qfHsyWeUsg7T0QhN01ksPPrdLqVy\naeWKFtPr9li6LsVikfPzC6rlKrVaPUXsLJOtra2U+W5ZHB4eks/n1g2oJMvsH+wzGo7I53M0GnWO\njg4JgoCPPvowlUJGqRy51+9zfHKCG8Z849d+jZPTE7rdCyRZZmtnj83mJtVKFUVKULSEq+sW1UqF\nOInY2tnijbe+9otfwB/9/Hvf2traZGd7m8VizvOnT1ANg1//tV/n9OSE7e1tKqUqm1vbBEFKdrl7\n7w6OkaaTabrCZDwkn8sxHA7XqTSWYSLJMqPJmEF/yA++/5dEcYgf+OzuHrC1s4mmpNacm1tblCup\nbGC5XGDbWTwvpNfvoqgKr16eMJu4VKo5+oMJO3u3uGwNyBcqlIoV8tkSqiTR73bRVRXXc9nc2lgz\nb5euz2w2Z29vH9u2efHiJYvFgmqtQpKEvHjxgvF4xObmBmEY8dbDh/QHIyRJpra5SRjCzt4trjod\ngjjGzmTQDJM4TCdKWVKYzeeMRqP1NLjeocoidCS9eRYLBRJiLMtcaebD9TQp4HNxMxYTs/ibgl1+\nc2IEvvA4AYtCWtxN02QymaxhX8FcF88pput1KMqNJkIQxsTj5vM5tm0zHo/XrFYx9cVxvLbVdV2X\nVqtFLpcmHImGRBRPAWMLNvzNdYDYx4tJW1VVLNNE1zRKxeIaKhbOcsKNTdd1DNMkl81SKBQoFovr\n3bzw/BZIxk27WYFEAF8wiBHowHQ6RZbTKVqgAAJVuOnhLrgEQRCs9++GbqQcEkVhNJkSJ6nz4GKZ\nkuT8MEJWNRauS4yEpKgkkoJhOYRRQjZfZDKeUKvVmUymaJoOK995ofsXHuk3JYQCtQHWaIP4HXE+\niffuOA6TyTiVhs4X5LI5Tl+/5i+/913+6A9/nzDyUVQZw7I4PTvDDz0MQ+fqqsVysSRCIgojKtUK\nzc0GP/3oJ9gZA1mRUU2dwWDAYrlgMp9yePiCzvUVjWqDaqlMtVrn+vqaH/3or5jOXXKVTbxQojee\n0u+P+PBnP8O0HOZzn0qpyhu377C5scPx8WsWyzme5/H48WPeeOMNsoU8k9kUw7TQNJUnT57y4MGb\n+J7P0dFrCrk89WqVwWCQ8jhkhUq1xsnpGZvbexRyeTzPZzyasLW7j65bhCEYmkUUQ6lUYTKZMpvP\nefL0KZlslvfef5/lcs5iOWNjo0m32yGfz7NcLtna2sTJZOh2uziZzPocXSzm1OsNhr0RpmViWRa9\nXo9MJkO73UbXNfzABSS2t7dRFQV3tmBrc4vXr1+nQTxOmpft+am2v1wuMxqNyeVyyJpKb9BHkWQm\nkxl/8id/wtLzqNZqSAnUqhWiMGA2W9kQeyGOY+M4OSzTZjKZ0mxskCDx9NlzRqMJCWn2d7lUwJAV\nIj+gVqunrmqGwWWrRRwlDAcjDg8PMQyDo8NjAj9gZ3+PXqfDW2+9RRhHxEmCHwREYYhu6OsB5eY1\n6jgOt24f0Gw28Lwl9+/d41/+yz/jnXfeQpYTKqUiqiZz6/YtFssFnu8TRj5f/dp7PH/2CMsyKGTz\nVCoVNE2lkM/QqKXhKFKShl8Fsc/bH/zmL34B/3/+xT/5Vrfb5fTkhMGgzzsP3+Ktt99G0zX8wOfg\n1gFHx0dAgqxItFuXTIZ9ck4G07bo9vrs7+8zWy7JFYuEUYyianz25DPOzy8ZDMa0222+8Y1v8pWv\nfECj0eDBg/skQLlSIV8oYTtZNnd2GYxGRMScn10ynEz5V3/+b8hkC1y3+8iKgesHPHtxzI9/8jF/\n8Hf+HrKkIUsaYRijajqfPXrE/fsPmK4C7j/++FOy2Ry+HzCbzZjN5rTbnbUxiGma2LbDeDxib2+P\n4XBEEMZ0uz0My6RQLLL0ArLZAuPZDElO4ynzpbTbTCSJpevTHw7WE6eY6sSUq+s6uVwOSUqLk2Wa\nyPLnkiYxJQqCmTBYEdOUmPoEozoMw3X0p/gnYGRhLyicz0Sxt237i5nXirKe2G/uqcXPgPXrg9Qz\nWxSo/69pXSAElmWRyWSwbZtGo0Ecp8lpwvNc7LAFPD8ajdYFRrwPAa2L9ya042IXL46tgJDFawiC\nAHU1fS6XS8bj8ToKVYS5iPcmmhZR0AWbX7wPMa0LhrhoNsRnIibYv56rLiSXa+38qoFTFIUkjrAt\nM715RTHeckGxkEeWJGzLSnXoskwu6xDFKTriuy6mqafET1lClqU1f2GxWKyMOj5XGQhpnWh+RAMp\njt1NToPYlU8mE3LZLEvPI5PPY+kWhqpx7/YB+UKGj3/+IVtb2/QHAx48eMBkPOX+vft8/3vfZzlf\nYFgGjz79BFmWyRUK/OEf/SHPXrzCdz2evXjG4ctX3LlzF0WWqVar5DMFbt+6y9nZJaPxlEq1wcKN\nuGz1qNQ3ePbykCSBw1ev6HZ6vPXm2zQaG+ztvcHzl6/YaGzg+x6DQZ/z83OKxQLvvvsu8uqc9v2A\nQqGIaabGPdPZFH0lfzw+PsKyDP6vP/u/uX37No36JqqqIyHx+HHKqJdlhXyphGGbuCtSaCLLZFZh\nTHEc8/DhQx6++w6NZpOL8wveeeedVAKWS3OrK5Uqi8UCQzfwV5yPi/MLLNPCMq3VYLTH69fHFItF\nHj9+TDabXZ3TMnvb2wz6A/q9XnrP0A1kSeLy8jLd4TvWujkPwxQJmk6nXF5e4vkhYRhxeXFJpVJJ\n115BQMZx+PiTTygWi0wmE27dOmCx9MhkM+zu7TMYjtB0nU63ix/4nJyeEMURR0dHVCsV2p0ululQ\nrtaIEhlklcurFqVKBT/wOTw6pFAsMJvPCcKIaq1GqVxi/+CAQi5HTIIXBBSKRQr5PMVCActO7xcf\nffTRekAQ/JXRJF2DappKo1Hhj//4Dzi4dUCtVmGzUWI86rG13SCMIu7eu0MUu5h6wrsP71LMZ5Gk\nmNFoQBR5XF1f4noLmrUGBwd7aIaCpWnc/ve0Uv0PQgf+3/39v5fcOjhguZyzv7vNZDjEsozVCaLz\n9PkzxuMpEHPvzl2kKKSSz/Lk5SH1ep3t3T0WiwXdbpckCsnYFmHgcev2bZZ+QK/dpXPdTmUCQcBl\nq0Uma6XJMopCPptD09Q0yCOMOD4/pFBu8A//4Z9g6QaVcoG33rnL5fUZ3faCt99+m3v37rG/fwvf\nD3j65HnKcg58arUKy8WCq6sr8rkimUyqH+31erz//vt8+9vfplqtIknJSlajYtsWp6enZLM5trd2\nefbiJVvbuxQqKaNUt0wM0079reMV1Bj4+L67uuGHSHy+m9Y0jdl8TnUlDRGFYTabrOFq4ohsNvuF\n9C2xCxZwu+hMp9MpuVzuxsQl3wg1UdeBI6KwADf0zZ+zyEUqWZKkmczD4XANsYobv4DZZVlmPp9/\nwXBlnewVhnirZkCWZdQVe10EZSwWi/VrFxelKLzitQvtttB13mxUgDWCMVqFNQi0YDabrfkYkiQx\nn8/JZrNrdzdgfexEsY1uFtEV1AysX5/QmDuOw2KxWDdQ4jUI4pcgu4l1hKZpJFHMZDJB1bXPIcAb\nGnPRNIibrUA+BMIBrLPPIV6vTcTrtm073VGvkAux2rjZ0MiyulYfiEQ5ofkPgoBKpUK3212fVzfR\nnOl0muryF3NQdSJJxTZMBtctpt0Of/QHv8dsPKbTvcbJZhmPx2lSFfC1r3yV0At5+fI5X/rSl3j+\n/DkbGxs8e/mC4XjEvQcPyDoWtm0ShCnMb2sGbuBjO1kK+fRzTINyHPKZLO3rbtrUJjGRHBMl6Qrs\n4vKMg719wihhORyyvb1NqZwjSeI1095xHHq9HmYmQ6fT4cGD+7x+fYJtZzDtTHqzCwPm0zHj4ZA7\nd29zdnbGoD9Kz8fFMh1I+j3uP3wr9W8Yz1AUjVq5vkYxDENnPp/jux7b2zt88sknmLaJbplIcYIi\nyQwGA95+/x1OXryi0agxn8/pDrqUSiV++MO/4r333mP31h0sy+JP//RP+e3f/m2ePXtCo9FgsZgR\neEvy+SK9wQBdVZn0xxQyOcaTIfPlDKeYo1KpEvjJugnWNINbt25z/PIlpmNi2gbDyTANtDGd9XXt\neR71ao2j18fMpgtyWQdNkYhlaU3gzOeLa7OTH3z/3zEcDNjZ2eHy7JwwDPnN3/x1Ti/O0TQFzdB5\n/vQFX/vaL63O137a3HtLtre3ma+QScuykGWZ09NTisUiAJqisvRcdF1jc3uHbru9bopdNzWUSnko\nPqenp3z961/n448/Zj4f8PDhW5yenrK5uUnrooXve9hOer9y7CxhGFEqVnj9+jWW5VAolDg+PmRn\na4Nhv0cchvzh3/+f/7104P9BTOCO5n5rc3MD29SRkoR8LkO0Yj0GYUASxwRhwP7+Pg8e3EPXVAbd\nLqVqLb1Bz+a43koqtrWJhEQhX6HX7zMYDJGAq9YluqEhKxIoUCs3qDXruL6PG7icXpyj6hr37t+j\n0dig0x1xen7NN775TXZ3t9nZ2aZYLvFf/Of/FV/+8pcBODs7R9d1Nrc2mYynNJpNWpcX9Ho9RqMR\npmmw0dzgonWBoafOU7lchvZVi92dHZysvWZaDwZDHrz5JodHx2xsbuGsWLqj6QRFS6HGIIqJpSS1\noYyCNZQaR+F6uhFTnWPbX9gz6rq6hoYBjNWNWHzN5/P11DyZTNb758Visb5hCya2mIAF5C5IXtls\nNpVyrXa+Qqt9U2Jmmiblcplut7vWZYu9unieKIrWvysIdeJnQRBQKpWIVkUojmPGkwnG6jnWO1VY\nT6hiUhZFRUi/RLMikAIhf7qpX74ZCSrsUW9Gi4omSJblNalONA9iEhW7a7FyUFUV0zTXLHr4fGcP\nrFEJsR4QE/jN1YR4vX7gI8mfZ6gXCoUvkOpEoRbIhUBZxGcoGpZ0FZKsX4vQw0+n0/XrF4iHOK4C\n6Vku3S9kqgvVw19XIvx1XoNQAciyjOe6aEa6pojDmKOXz3FMjUatimGoyKQRjrVqFQlSPgIyuqrh\nuktcNzUp2d7bZbn0+PrXfxl36fIXf/Fv02CN8QRJkhkNhnz2+AnNZpOjk0uuO31y+RKb2/sMxjOQ\nFEw7Q7lUoFQqUqqWuLg8o9vuYFkWpmkhxzGOYxHFIdrKSnQ4TAvVeDxGXjWlsiwzmUywM1kmkykJ\nMpValcuLSzRDZzFfMB5PCPwwtZw1DO7fe8BisaBSq3B0eMxoMOIbv/rrNBpN2u3r9f1isViwdF3y\nhTzTWZreF4SpW5plmsRJjGmZaLKCYeh0+j1kWUFRVBRNpVAoo6jpuZHP57m4uKBSqTIY9CkUikiy\nzHQyISZiNp2Rc9Jru9vrggwvD495+Na7HB+fUCoVV42xSRjHRCurXNMwUZCIonS15fo+mqryySef\nkMtmqdVrRFHMYrHkwcO3CMOITqdLpVKlXC7z4x//mEwmw9MnT3l9fMbTz55ycnLGe+99GdOyse0s\nhUKRYjENipnNptRq1bTBX84pl8ssFikSmiaK5dYNvKKkaWH9Xp/mRpPpdAoyNGr1Ncm23b5e3wsk\nKVUW6bpBtVrDUgzmkznu3EOVFQzNYjTs892/+C6T6YxBt89oMOa61ebpk8dkshl6vR7VYgGFGFPT\nyGUy7Lzz67/4EPqPv/svv+XYJv1ul+lkxGwyIpfLMhmN8F2X2WzGZnODXC5HuVBgNByiyTJRHK91\nzFubKStwNp6Sy2WRVJXpbIqmyIxHfbLZDFub2+QKBfw4Io6g1qwRxiFX19dUq1XqtQbj4ZTRaEaU\nSGzv3uLOnbs0NzbIF/Nsb22nBhvEjEZD+r0+8/kCWZbSfdx8yaeffpJ25yv3phcvX5DLZYmjmE6n\nTS5jc3ZyQnMl95hMJyRJanwxHE+wMg5zz8ULI6aLOYqqEsYRYZjC4Wto0/NWlosymppOWLZhouqp\nJCsteksURcayUg/elKHtpTDoag+pKGnudj6fX091YscrTuRisbiGqavV6hpqs20bKyc5xAAAIABJ\nREFUYK3fTqf82bqQCe32zf2sMEgRsiLRdIgdt4DpRQEUunAxeQsteXhjR2+aKSw8m07XrG3xv3gu\nUXjEPlxMzGLnJaZr8dzi+QSEL5LKbsLBwkhGTJ1i2r2Zmnbz/YhjJaZoUcjFpC7+rrAZzefzX3j+\nm3tmcSMPw5BSqbSGrIMowg8CTMtCVhT81TQhGhGxRhDNhfg+bUwSkiRekxMFknFTaSCaOtFgTFde\n02Ii7/V666x4wWEQxz711C+xtbUFsD7PoiiiVC4RJwnGygLVVBU0WaJaLbPRbNBpt9nZ3kZZPe9/\n+sd/h9PTM84vLvDDENNOdcHj8QRZUSiXy/z0pz/l7XfeZnt7h08//ZRuu0vnusOdu/dIkOj1RyiK\nyvn5xZq8+Of/+l9j2zalco5/8+0/57J1yVtvvkmz2SQOQnZ2d/nyu2+jqBLD4YBGo0G32+b582c8\neHA/vR+on0v+MrkCs9mCUrm6MkEZY5gm5+dnSJKCadlkMwVevz5la2eT3qBPrbnBcDzCMA0ePHib\najWNPL7utAmiEEmGyXiEqirM5uPUPKVYIF8oEMcJygq98vwAVZG5bF0hSTKXV5fM5jMcO5U6RnEq\njxTnz2Kx4PXrE2azObPZjOPDY2bTMZubG7w+PKK5sYGiqsSAYTjoukm73aFer/Pi8BDHyeL7PnN3\niaJqyIlEpVhisVhiOxaFUp44DCFm5ea2xHEyDKdz8qUKSeDjuS6e75IkMZZhEIURhqpyfHTE3/qt\n36JWr7G3v0ev16FUSe+xXuBSLOVxbAvD0NNAES09v6fjCZqurWFxSZIY9PqQJDi2g2maTCcThqMh\nmqJSqVfRDTNNP1NVGo0G8/kiRRtWa6o0oKSM54c0NpoYRobxZMbx0Wvu3rnHlz/4gH53yPVVl3K5\nxPbWDi9eveLd975Es1zBcWxq1SqnJ8fc/drfgDCTv/run33rs0ef4rkLvMWS+XSMqsgYmsrmRjO9\n4boujmX9v9y9yZNk933t97nzkPOcWXNXj0CjgcYMEOITSYkSQ3ov3vOTw+GFF3Y4XoQX74/A3jvb\nC4fDS28sS5YlU6LEJ1IkAZEEwMbQQM9dVd01V1blnHnnwYubv0SCXnpjqiMqOrq68lbmzZv3fL/n\nnO/5crB/wKDXw7Izw1CSpKytrjIejTB0DVXRODk6QrdkLEPl+PA5jVqVyAvZ3X3GaOaRL9YoFPME\nacBwNCCJEkzdZDZ0CL0IPwZJ0ugNRwRhwOnZKVuXLnHR7QGZvrmzs8PW5iXa7Ra9Xp9yucyoP2R9\nY53xeIxhGPz9P/wDf/D9P2AwHGDbFooi0T095Z133ubmzRezjTXTGR9+8AE3XriJmcvhBCGGbTEY\njylXKli2jaLpBGGYmXymE+IkIgyDbOVk4KOQrc9MkgTTyEZDDE3HNk3iMMI0dCrlMv58EUB5DtaC\nGi6VSotuTXRKAiQEyC7T0gI4lmNKl2ly0fEJXVnQ+OIxCxD+rXlt8Uf8fuHSFmNpy4CfzHVmAUrh\nvJCTYDHSJMJiBPAJelkYvwR1LF7HMq283G2Lx0iSRLlcXjzecZysoJsHxQhGRACmCJIRna7QysVx\nlyUDwQgI5gH4xvkSRjtROAmazzRNXN9nMp0uOnFgkbsezV+zGNdjfn7E8xNau3hMkqTzzPIURclm\nn4MgJElS4jhBUVRUVVkUYradXxRg2XYpczHuJnLeJUnKdNO5dDEcDhez/0IeUA2FwA1wZy7VYplC\nzmI0OOfdt9/ggw9+DlFC4PscHBzQPeuSz+dxXY9Wq8Urt2/jOA6O69Lr97l8+TL7+/uYpkk+X+Cd\nd97l+bMDBoMBf/z9P6a9ssKzvWdsdFZY77QwVYVaOc/56TEH+3u8cOMq08mEW7dexgv8LMjJ8bAs\nm+lsRrWUy4xeQcDZ2QmNRmMhDfm+x/rGJoqSxTqHUcxpt0uxUMLO55nOpnTaK/R6PdY3t5BQKZTK\nzGYul65v4/gexyenlGsVNMMgkUBSFXZ3HnNycsKlS5lcaOcsAt+hVqsSRQH1Rp0wStnf3ydfLOA6\nDo7vMRlPKBSKOK7D5uYW49EEx/colitMJhOazSaDwWBxD/g6ZljH1HUOD/eplMo0W228IKBYzlYc\nNxsrbG5uMRqOqTbqZPWpRLfbpVQuMXMc7FyeXD6fgbFtoqlKBqiaimnbPHnyhFq1ztO9fcrVBr2z\nA1zXIZ/PkcvZ+EEWfV2rlNnaXKfbPeZb33qLk+MDGq0aR4fP6A3OMQ2N2XRGtVal3+8hzyW60M/u\nMdVKhYP9A8ajEWmS3TdE03JwkFHyfjCXwJKUOE14uvOUQi7bUFir1Tg+PmZjY4NcLs/JySmT2YhW\np0V30GPiuLiuT6FUo7O2wS8++BnvvPMOjVqDdrvDK6/d5g++/0dsbG7zdHeP0XTGabfL7t4+b//R\nf/m7D+BPvvzn9w/295mORuiawu2Xb2Ho2Q1B1w1URcEyTay5+9jQdQxDQ9MNNE0lny/gus7cdZvN\nD9ZqRS66XXzP4dLGBmcnZ+w+22dtbQPVMPGnY0wzmymvVmuMxy53v7xPFMIsiOgPhjTbTUzTwLJN\nTk/OiJME13EJg4hiqcDO011M0+Szzz7l/v0HFHK5zEkaBJydnaHpOrqhk21aO6JcKrG2ssrDhw9R\nFIUvvvgCWde4cvkaVs4mSsGPYvw425AWhFlO9enp2ZySt74xY5tpdxa2aVEoFGg2m4tu0vd9FFWi\nUMjCW4TbetnwJLpske29TJMC35iNFjr5Mt0sdF7RpTmO8421ocu0t3CBC0ASwBdF0SLRbTLvoJfn\ntUX4idDc8/kMMML5vLQoIITmm85nzZdNVQIohC4/mUwW5jGxgEV03GLkSRQky52qAFtxLsbjMaqq\nUi6XFx33cnrbsp9APF4UCCL45LdpcrHVTZzj5VWoy0WGYDkSWLAftm0vun9hYFSEZDJ/vbZtLwqf\nYrHIePy1L0IUFOJ9EsyK8EcICjIMIzRNJ46TBaMgfkYUO+I1iut1Op0uCgixfWo2m1GtVjNGKfSJ\nwwQpSTFUlWGvh6rA9qVNvrp7lz/6wz/iq6++giSl2WigalpWWMzPy/7+/sKseXh4SLvdplAosL9/\nwOnpKYZhUC5XqJarfPXlV1zavszOk4c0Gw3C0OfB/XsU8jluvfQSOdvi6dNn7D3f4/Yrr/KLD35B\nu9XKZrfjmPHwgmKxiOvOODg44MqVK4vPV6fTIZpLD5ph0+sNKJZKmKZFOE8HS0m5OO/RbDQpFIuo\nikKpXCZOg6y7q1WIo5AkzBaYlMtFPvv8U6rVMlvrG4SBT7NR4+HDh6yurnBx3mXmuOzuPWc4GrOy\n0qFSrXLR62NaJrKqMJ05bGxt8cWXX7K6ukarlW1ve/DgAe12m36/TxRFPH70hOlkyvalbdqtBpVS\nmYuLcyRJJl8o0j3vMZ3OSBP4/PPPM2Yq8nEchziJgZR2o85kOqNQKVGqVsjnc/jOlEqxgKUb7Ozt\ngSQRhQkXvS7lWo1ypUbBUigUc/T7PVzXwZmOKJbyc3+FSpJE8xW3MJtNOOuesrbaRpbS+QY9Bd9x\n0HWDOMyaAyENHh8fz3MIpgsKvdvtEoYZC7m7+5RWu4XvexzsPyfwArL97NnWyiAIuHv3Lv1+D0WR\nQc42+KXpfFRW1Tg7O8IwNc4vTgjDiMF4SJomDEZjxpMZsmqQz5d49myfDz78Na32Kq9/99/97gP4\nBz/+y/ejKOLy9iVqtSrj0ZAkib+RBlYqlXBmM8x5NyLNNUcRjK+qCs7UYX9/n7W1VZJYQtd0ioUS\n42EWyK9oGiEppp2jVSxxcnLM7u4erc4a9x/uEMsqB90LSOH8okejXiOXz5yfuVwe0zCywImz7uIG\n++DBI4IgZGtri7WVVVAy+uqdd97h888/Z2trE8uyMod5f0CUxOiaztR1WN3Y4NoLN0klhYnj4IYR\nsqJmIwlz7SUMo7mj2FgArLgRC7q7Vq0uOlxhulAUCebjQ9PpdHFzFXp1lgQ3W4CXAGBBEcPXISjL\nRigB7oJmns1mc+dtRvX6S5StAKxlLVpo3YKuF07zZfpZFBqiYxNjRwLkwjAk5WujlQB73/exczm0\nORAtu9RVVeVi7qgVv0sEpAj6V4CkMG/99msSQLdciIhzsZz/Ls6RON7yzxiGsTi2+BKde6FQYDqd\nUpzvexehLMJnsKwpi44pCLOlKeJzIgx7Qs+vViqL8ysKHjEBIAovMYEAfKNTF8WTYGoECyNMWyKA\nJkvBmi0WuIhpCHEuBT0tHNTiuS7eyzQlJSEKQizDwnUc7j+4z9tvvp6t9i0WiMN4UdiZpslbb7/N\n8fEJw+GQSqWyKGYFQ2LbNnt7e7iux8pKB8/zqJTL2IbJO+++y9//+EdsX7qK7/vs7u1RLle5duM6\nlWqV3b1nrK2tYuVsBsMhlmHRbDYI/YBKtYQzG85ng3dYX1+nUCjw5MkTKpVKlvmu68xmDuVSlnSW\nAqZlUCwWCHyPQb9Hu92iWChwfHxEMs9nqBSL3P/yK7pHx0xHA65dvsLp4SHVYgEkmY31dSajEePR\nhGIhT5JEnJycYJo6vV6fdmeNUqlMpVKm1+th2zlarSZfffXVIn9e0zRardbCCR5FEWtra5ycnFAu\nlzk5OQUyeWP/+XMi38OZTTEtm1KpzGQyBUUmTSLsnI2mq6x2WuRtG9syqVerjIZ9Ou02fhTQaNSJ\nowA5iRn1+hwdHXB61mXm+FQbdVY6bVZXV7P8juE5tUqVNI345OOPFrkIjXqd6dRBVTXq9QatVhvT\ntGg125RLVVzHw7YsTMPAmc2wjOx6nM1mBEFIFIWLojZJElqtJrqepXrevn07K1Jtk0I+28AmsjLK\n5RJhGKApGuPRiNl0yr2v7vHiizeY9ENyZp4oyALFjg/20dWUnK1y+epVrl2/Si6fmSQdzyGfK3J4\ndIYcw3TikEQp6+tbXH/zu7/7AO6PDt9vNBoU83l0XWPQ76FpOr4fLG4OghJUFIViscB0mhlgxuMx\nu7u781ncLCrVcbPEttnMIY5SNN3EDyNOz3rEyDzZ2YU4RZIU+oMRz58dUmk0KVaa/Hf/8T8SRREr\nnQ7lQgHbtjk4PMwoM9/j/r2HQFaVQUbzvv76G5kbfmODK1euMJlMePHFF5ElKaOzdZ0nj58wGo1o\nr3RIJcgVCkSk9Adjpq6HmcuRxCmmZYMso+sGYZAQRymWbS1oVzECJfRkVVVR5UyjFNR9BiQytm0t\nxq1E/KegdaMoolQqLQxNy6liAtjEBS9ABFh0aeJxAsiTJJl3Je4CWE3TzEZZ5l2heP9EMSGoYqEP\ni58T4CtCVgQFLWhKVVUpFIvEcbwY0xJA4rou4bwAqlQqi25cxHkKMBFAIzpw8UdsgVtOaxP/Xh4B\n832fwWCw6L5FgSLOsei0xe8Wr1MUG0IOEPqy0MWX2RBxrsQ5ER24eA5RFBGEX8fSAov3RnTW/V5v\nAdZC+xd0vCg4ZrPZonASRZaYLRefMeHwF+yPGMsT14owowlGRoC3eL/EeyWKACGPTCaTzHzoTFBl\nncDL5J+T42MgplmvMer15+amOpZhUigWOb+44Oj4hCtXrnDnN7/h2fPn3zD53blzZ05tZ1nXmqZx\n94svUEjp9S+o1moMhiMmsxmyqhAnMamU3SsePX5CvValXClhWMbcaS6hajLNVpVB74JSqcTq6up8\nQ1ltUTR4nsd4OsW0LAqFImEUIksSqqZydHTI4f4+tmXR711QKhVxphPKlRK+5xLGcbbbPohY63T4\n2c/+id3dpzSbLSrlEns7e1zauoQqq0CCIkmcd7uQRly+ch1Ns1FklbOzExxnysbaJgeHB2xubgIs\nJjrOzs4Wn8tarUaxWGR7O9uUFUQh165f5/jkmE6rwZ1PPkHTdJJUolAoEccx21ubXNreIJ/LEQQe\nSRpRrZXwXJetrU3c2YTRaESjViUOPULPI29Z9C56xIFHECe4fsh3vvtdHt77kmLexrIMosBjNBqh\n6wZPHj/FNCzW1tZ59uw5sizTbLQJwwhV0TLz28zF83zCMMi2UJ6dMej1adSbjMZjFEWl1+vheC7j\n0ZiXXrqZeXiKOfqDHvVGjSSJefZsj3q1wt7uHmenp8RRTC6fI2dZxFGE6zhZobHS4eqVy1QrJUyz\nzGw2zSaEDI1c3kaRUnRdxTQtbCtP97zL9uXL6KpGs9HgN7/+DYqssLW1xcbGRnYub//e7z6A//Kn\nf/O+aWTB9U92nmDNxyU+/fRTTNOk08kqaDGfq6oK5XIJy7I4PT2l0+mgGyqtZpPT0xMODw+wbZun\nT5+gGyYPHjzG8xPCCJ4fdrm4mPBkf4+dp7scHBxjGCY3X3iZOE44PDxEUVVW2m1i32d3dzcDljTb\nf1wtN6hUqpimwU9+8lPee+/3qNVq/OxnP1vMKpdKJT7++GM8z6NVb3LR7VJr1NFNg4uLCzY2NzFz\nOcaTGYqsoxo6w9GYyTQzBEVxymQyXVDNfpB1RJZlLbohy7Ky7VzzFLLZbLbIl5blbCSJ+TpK4UgW\n41LL+qf4WtaGBXCLbkeMejmOsxiVEgAsHieCUZZngJe1Y6GTLlPwonAQXeFy2pgwcqmquujwxeNU\nVWUyjwm1bXuh2y+6xTRFn5unBG1uGMaiCFyePRcUsKCQRTEgvi+0evEzwjUvgE4AhqColzVzcXwB\n1OJ1LqfSLXf/AjgF4C4715dpfk3TFuthVUXBmx9PUPbL4FqcU7viPIiFNgKMxby4AGvxfCaTyTe6\nclFgCHPhsj9AmBRFISauH9HBi/OSTUPoiyCbyWQCZMAyno6oVeskUcxoMCZfyPGf//t/y6ifLdK4\ndOUKz/b20FSNnd1d7n71JVeuXKXVaiFLEpe3tymVSuRLRQq5PIVCAc/z2N7e5ujoCEVR2N7eIgkj\ndnZ3CTyfnGEynQxZW2lRKRW4tLXJr375SzzXodNpcXx6QkpKvlTEtgwsW8s05/lWrWKxSKFQYDAY\nsLW1zXQ64+TklGarhef7FIslJnPpZjTqZ7P0pLRbTUqVEooEuZzNaDCgUikTySqFYoUXb97k/sOv\nGE/GXLp8GUVT6fW6NOoN1tc3mI1nTCdjwiDAMi0cd4ptF2h31rm46DEcDYDsM9FqtfA8j2azuYiy\ndRyHzc1Nms0mFxcX84JqxuHhEcVSiY8//oTNzU2e7e4QBSGdVgdNN5nOptmWr34P3VBQNZVypYSu\nKuRymfTV7Z6DBIah8+j+fcr5PJZh4LseT58+xdRlDDOHVSrTarWQ0gRTkzk5OqLVaBGEEa7rcevW\nS4zHY1ZW1hiNxly/foUoCoiTeL4ZLiIOQ9rtFq4z4+K8h2lkXpl2q8N0MsUwTSwzR6FYolqroOka\nhYLNyckJhqHR7Z7huB66pvH40UNMM0uvy+dz1GtVLMuk0ajjui5ffvnVPJgpk8MkzcSPPMIkIEpi\nZq7LxXmPcqXB2ckJ5UqFJI5Jk5hOp42pG7TrLb569IDNS5tMHYeZ63D11f9vc+D/vwDwX//sh+/3\n+z3KxSKKrDCejAh8H8swsfJFCsUCVs5iNplSrVaRZQXXnZEmQTY3WqySs/Ic7z+nlM+czE6Y0Ky1\nePjlIw4Oz/j04WNOJh73d46wKx0Ojo4pV9r86b/7L/jeH/0JhWIBL3CwLZ3Tg33+p//hf+Rb3/49\nev0+hUKB89NzDg8O2d8/xPd9Pvzwn/nTP/3XkEr87d/+HbaVo9Gs4TgOh8eHKEqml/kzF2c8ZTqb\nUqlWkRQZLwzwgxAUheFsliVJSSmqbhJECYP+AFWWQZKyzF7dxLQMFEXCskyKxQJxnHV5lm4sAOdr\nY1pK1vQlC71nPB4jSdIiAUx0SMujPOKGK/RaSZIWoSACWASIiJEk0eEDi2MAi1xnXddJE0iSFEn6\nugMX2uoygIkRK9/3F4lr4t8CEBdFR5Jg6JkOtcwUiA7VME0kWBQqAtxEKIug75e3oi27w5dfl67r\ni8JJHE/sGpdlmUKhsNCkRXcrno/4I3R+AYBC11d1Hc/3UefdvXCji245DEMqlcrisYK+Fg5u5h33\nshwhOnpVVYnm4LrccQumQtDnYgRKFHlinE0wKuK9ER2c6JyFR0IUQ+I1ietLMBMih+C3/QxCVz8/\nP8fKmSRRJiOM+gPOjo4Y9Hq8cOMqjx4/Qlc0oiBLpQvCgFK5zPb2JU67p8xmLoeHR5TLFQxNn2dC\nXDCbTJlMJ5SKRd54/XVKpSJ7+8+RJYlXX7lNoVDg2rXryLKapdL5ETNnzNbWJnahiB/65HIWzmyK\nbqhMpzMSKSX0PNrtFZ48eoKsZB3XZ5/dgTThyeMH3HrpFVzfR9UNUgkc18GbTtElGcvQicMIXdVw\nnAlB5KKZRvaFQRSE+GFInKS0VzeQNZ2NrW28OGVz+wqWmef05JTJaIzrZBnntVqN0XhC72LAa6+/\nhqQogISUZrsRMqf1lDSF+/cfEKcJN2/e5PDwCN0wMu+JZVIo5EnihFKxiKEb2KbBaqtDpVLBzFlE\nJKysrVCuVlCkBDtnMRj0qJQrHB0cUimXOO+ekqTwwtWr/PLnv+Dqxha2bXJyfsph94Trr95k/+CY\nVqONIkkYmsL+sx3kJKXebjEcDucFuUapXMDOmVRL9axo0LMCv93pMBmPs3u266HJMqEX4DgOtXqZ\nwaCPYZaQZZ1u9xTH9SgXS5RLJdI0xHEmJElMPp/D8z2qlRJSElLK5zN2YXMT1/WQpYSz0xN8z6NS\nrRJ6HrVKifFwSJImSGnM2fERhqoyGc24efMWqqrhuBNyuRylSpFnz5/x/NlzSqUcaeQRJjFICZVq\nmcFowLVXv/O7D+Cf/vMP36+W8zQaNWRFwjAN2p02K50OGhI50ySNQga9AaEf0ju/4OL8hMf3n/L4\n809IJ2f4swEPnuzxwa9+Q+yHJNMxF+dDBl5MpbNJqdbh2tUr/OAPv8cPvv9tXr11m9du3cSdjfjw\n5z9jOh4jxzAZTIjimDfffJPpzCFNJNrtFeIo5fmzfd59993spjfMdCzbzrG3t0ens0q10uT+vQeY\nhknONJhNRxydHbO2tY5ZrKDmbCTDwk9lZN3E8UOiGCaTMZB1PbPJjPyciiNN0RQV28qMfKahY+ga\nge9j6CqWaeC4s2wXcBQgKxKe56BpylxzKy40RqE/LpvPBNiKrlOAznKUqKDbl/PDRUcrwEY4mYfD\nYcaShDHj0RhZygxPYkZXQkJVvw5sWY5jFWCwrIcvj1AJDTafzy/oP8dxIE2zbPc0xZ1nkEdhSDjv\nCAV9HQTBwiS37A6Hr/Vp8T0BZJZlLWjg5cKmUCgsHODL6XGiWxc0tgitEGzFcupakiTZZqs5ZS9G\nvxzXRZJl1PnjBV0v6PvRaLQY5VIUBdIUz3VJ4hjTMIjCjLINfB9vzmCI5yGuA1GciUJBGAdHoxHA\n4ntCCwcWv1+8dpFYt+w/EDS8cJkLbT6TvYqLx4nwG/Ge1ut1et0e1UqVOM2MTaapsbG6gq6oBG5A\nt3tGoVjEcbNwjduvvspp9ywbc6yWmc0mNBo1PNfB8xyuX7mMpiq02i2atRoX3S5//X//DS++dJOL\nXi8rbPyAJ0+e4Hkejx4/RJZlbr18k729PTZX1wgDl9D3cGYjIs+j3WhgGjKDs2NmswmSRLb1L59H\n0Q3MfInGyhpra6sokkLguXz0619RsGy++PxzxqMR7Y1NKpU6Fxd9tjcu0Tu7gDDh2ZMdpCRCVyWG\nF12a9SpSHFG0bc7PzghnWREwm47JF/MEachgOsCwDar1FpPpjHKpiixJXJydkAYOchSQAs5oTBqF\naLJEKZ/j5osvICUJUTSjWLA5eL6LZZr4nku90aDTabOy2iFyPV55+RaSItFs1cnnLdZWO4xHA2RZ\nQZYlFEVFUw2GozGBnxX1zUaVO3c+4a233iRMI1zfY+vSJSrlMrqss711CRmJ4aBPPmehGxa6brH7\n7CnlcglV1SiVioxGQywzx2g4ppArcu/efaq1CqQpqqLz8UefkCLx8OFj/Fjj6d4+65cu0V5bo9ps\noFomaDKB6yPJEPgelUqZwaBHkiT0+0MUskVUoaTxyhtv8HRvl3/8yY9xphMU2URRNHLFMoVihTBN\nGE0naKZOoZBR9pcvX+bk5JTD/QNOT7O94fVmi3Z7Bcfxef78CN2wiRMFwy5yenaGaVpYlo2mqqzd\nePt3H8DvfPA371+9ehVNVehdXHBpe5vZdEq9Wqd33kNSZO7du4+dy/PRr39Np9Xk4NkOxVKV48MD\nXn/9DY7Oenxxb4fh1Gc6cdi+dJndozNSLc/q5haNWoPtzQ2uXtlm58kT4ihbq3nePePy5W00WaFQ\nKPDpp5+x93yPNJXI5XMMBkNWVtb48T/8J9IUGo06z/f3KJfLnJ6e4HkuZ6dd0hSGwxGNRp3JZMyg\nf8HJWZfbr79Ord7ECWMSWWI4neGFERf9IVEYoasGqibjud5cz5Sznd/lCpqqUigWUFWFXM4iJVl0\nkoK2VJQMFCFFliVsO8th9n2POE4WgCEAW+iropNd1ldFlya+J4xa4uYtOnXRPS1HYgqK17IsRsPR\nXKvPfAggYds5TNMgSVKQWJjSlrtqofGLrk9ovst6tACENE0Xu7PF84ev57VFxyxcqMKdL6hdIQXY\ntr0IfxGAI5gMQfGLYkO4ssUxxNpQMb8uOnsBjkLjF+504RlYxNzCwkAmzH0L5/+cdl/2Cghn/XK6\nnigqRIcsMtJFV7wcsCJ0dVGUiDhc8Z6L4y7LALZtL3woy0yJAGyhZS9LC4LCF68dmNPIo8XPiKJw\nIdeECUggK1AsFXj06AFHBwfUKxXylk0ub9Pr9bIlJteucXRyzN6zPdrtNrZtLwJnnJnD2fEJg8EA\nGYl+v8+dO3fo9Xq8/c472Dmb+/fu885bb5Ofhwx1u92MZq1W8AOfJIm5cvmzmsIPAAAgAElEQVQy\nxXKB/mjAxvoavX6P824XRVXR9cw8evX6dc6659QaDWRZAUkmkSBwXRRZoX9xwWd37mSLdlQ100Lb\nbU6PT2lUa2iKwsHhPooks762ns13j0dUqxVMw+CLzz+ne9bF1HU818MPApBVmu02B0fH5Kw8q6tr\nxHFKqVhbmOkC38E2DE4OD/lPP/kxl7Y3MTSV58/3kGUIAjcLy0qy6QfP9SDNukJFBtKIfq9LMW8z\nmgwZDvtEYUZfj0djDN2gP+jjOC4HBweUK1V6FxfkczahHyDLsL6+znQ2pVAsEISZD2Q8HlMpl/Gc\nbNGOxDyQxvWQJBXdlNl5usvGxjrD4RDbylEsFvHcrBi1TJOVtTZBEPLDH/4ts6nH8+fPUDWN+/cf\nE6cJr7x2CxSZYqm4uO81mw2m4wmaKuP73vxazrIC8rkcF71zysUCgeeSz+XprKwxHE+Zuh6d1Q32\nnj8nimO2tjYYjYcUS0VOjs+5ffsVAFZX19A1gyj0WV9fwTB1PNdBBgLXp1GrsbGxiabrHB4e4Dgu\nxWKRg4MDXnzz+7/7AN7b/+J9RZF5vruHJMvkbJtKsYznuPzqVx/z43/8CcPhmK/u3ScMMnf2bDKk\nUKlRrrf46vE+50OP896UXn/C2+/9Hj/6yYe8+PpbjGczpFSilLPI2xYffvghf/03f8PW1iYfffRr\n1tfWmE6nNFpNBqMhyDLd7jmGYXB21uWTTz5h9+ku9XoDRdFQlCzAQZJYxIG+/vobnJycsr29mY21\nFWxkRabXH3Dp2nXu3n+EbhpMphOiJGU6m6HJKoosE4Q+vp91h+VyOTOheR6lYgFd1+ZhLdl5kuWv\nzWTT6ZharUocp7iuh21na/TCMEKS5HlBMVyAlugIl7dbiTWeQgNdnrUWbnUBbst6tojNdF0X27YX\nHediYYWsEATRwmwnjqUo8nw2XFp0rMtdfS6XWzAGAnzEv0XXLyhZUZgs0/7AYp+5JEn0er2Fhi/O\nwfKilGWzmtCgl8fckiRZGN/gawOfcMOL9DXxvJbjVIXLfXkP9vLMtZABAt+nUa/jzCl4VVWR5hp9\nNkb5zXhUMXK27KIXG8yWQVGwK8tmMnEuxHkXr1kUb8s0+2QyYTgcLt4nUUiJsJsgCBiNRgsZRDA1\nYjxOxOuK3/V1opW0eB5iCiKfzzMejqjVa9naz1KRRw8ekDcttje2ePnFl5CUbAZfbK9TVJWV1RU0\nTVs8T2Fg7LTbxHHMo4ePcOeBKjdv3uSs2yWXzxOFEbPpFGlelB0eHlIoFphMpjjulKOjQxRV4dcf\nf8x4OmL7ymWGwwkJEtuXr2TjpFFEKmXb/E5PjtFVjVw+RxAGFIpFQj8gDHyePHpCq9lib+c5J8cn\nvPnm65wcHrC60kaSM/YnSmP2nj+jVq+xu7fHzHHwfJ92p8PG5ibd83NuvngTy7awCwWGY4eD/WNM\nw0ZKFCRJIYpiwjAiDCNMw0BR4PGTJwwG2eavcqVErVYhikN0Tc/GyyQZTdWolMsMRyPq9Rrd7gmu\nO8W2TeI4W9Axc2cEvk/gBTQbDWaOQ7VW5fneM8qlCuVyFd/PFs4EnsdsMmHmOABcvnKFwPezdbaa\nRhRmBXG3e0azVafbPWNtbQNIkeSUJE5pNpvfKE4lZPq9Pq2VJnEc0ev1kdHp9QZ8efceKyttNjY3\nee/b71JvNDg5O+H4+BhNkTk6PCIOfNzZDMsyMXSFNEmZjMeYhoXru5mGr2sEvstoNMX1Y5ANkhTq\nzSaGaTEaDqmUi0wnY3K2hWlmTNbe3h6e55PL2wz6fXI5m1q1iJRE9M+7mLrCeDjg+OSYOA5RVZ3V\n1VWCIODp06e89d3/7HcfwM9377wf+B6z6YScbSGlEqHvs/v0KYZt02q1UHSD4XiGblgcnByjaho7\nB4fU2xv85u5DklTl4mLAO++8S7na4P/6h5/SG4y5sn2ZnKlz9/M7/OxnP+W0e0a93qJer9JqNun1\n+xjzG8vx8TH/+NOfcOXyFd577z0uX96m1+sT+CEbG5uUyxXCyJ2nF9VYWVnJ5v2GfQo5izfeep1L\nl7forHSwcnnypQrDmYeVyzMaD5k62XpGGQV13pWNx0NkWVkknI3HQ6qVMpqqoKoKlWo565SUTE8V\nCyRM08J1PTRNo1AoLEaShKta6LjCiLY8GrY8nifoVdHFLs8Bi1ndZbOaMCAJUF6OERWUe5qkeJ6/\n6NgEuKmqWITiLkBAdKei+xSd4zIQis58mcYXgLOsN4sPvAAkkZQmzG3AAkAFsIjEs+U/4rGC5RDn\nUui3goUQ50r8Lc77su6+POYmYm3FKJkoFEI/wLatbCfyUqefz+cXcoI4tjCYiedhzDVMcf6X42KX\n3e9CjxceBuGIF9nr4jyKomN52mB5bE4Y8fL5/DeuF8GaCNCO45j6PItfHEuE6gCL89Tv96nVargz\nl3whz2DYB1LiKGR7c4vXXn6FB/fv89Ktm9y5c4eNjQ0cx2Fjc5NCsci1a9eYjGc0Gk2CIESWFSaj\nCSsrq3TaHdbW1zJD1rNn3HjxBcaTCb/33nucd7ucnZxy1u1y9epVWu02u7u7vPDCdSwryzLorK9i\n2iaj8YRCvojnRxi5AtPZjHK5gh8E+IFP3rJJkhjbNHADn3a7w0X3HNuy+Kef/QzbzHHv3gNM3caZ\njXGcEZVqieFwQLFcxszZRGlCPl+kUq1SKpepVauMx+NF2EoURzRaLRwnoHtxwcbqGqZukc8XKFdK\n7OzsUCgUaLVa7O8/JwizCYtr17ZptZpEUYgiSaRzGWs0GqKrNo7jsr//nHqtRhJFWIbBtWtX8OYj\nulPHYTAYUMwX0TSderVG9+yCMAqxDINef0CxUiEIQ0aDzMdULORx5rkco/F4cf/wPI8kTpk5E2r1\nKo7jZMtexhNkOZvvXumscnJyhudlvz+YG/VMyyRJQj755BMK+TLlUoO/+j//GoBrV6/ygz/5Pvli\nDlXTicOYQf+CTrvNva/uc3F2SrPZIIlDjg8OuLS1RegHFPIFoiTK1hHHEa4b4PoRtl1iPJ0hSSmD\nwYB6tYqqqtz94vO5y36GbuX4+KOPsG2bnZ0dfvWrX/HSzZucnByjSCnPn+9hGtke84cPH2LoBs1W\nk9F4urh/1Go1Lt36F+BCv//xj953nBmKItOo1xiNBnx19wtsw2R1bRXDNOgNRhQqVdorGxx3L8iX\nyxhmjucHJ8QppHFMMadjmQZxqrD94i3WOytc27qEbetsb29gF0zefPMNvvfd7/Hyyy/RPe2y0lnB\ncZzFCr7RcMDbb7/DzZs3efToEefn51y5chWQODg4ZG2tw7Vr1+j1etnCklKRLz//gjRNmMzG6IbJ\nT376T+h2jrHrIWka4+mE8WRKrlBAIhv+d2YuhqYiqTKGYuL6LkmS3TxNQ8/oZillNt8CtWxUMwyD\nfD6/AAhxgzZNc+GMXtYlRVynMJ8JSlY4jwUYCdOUcBmnaTrfYiYtAGI50EUcQ1DoaRpj2zlcJ4tI\nBBYLQwBsO5MBfhtgfS/Asq2FI93zvAXoL5u3hOFOUL/CGLas2YtuWBQVwuy1zBosa+8CUJbDZyzL\nwnGchZ4tRqoExS5AXXT7oogRxjfx86JTX2ZAgAXjoUgycRSTRPOFL5qGBMRRhDJ/D4SBTsgWwgkv\nntfycxPdfhAEi1AdyCYSPM9bpMstJ8OJ+f98Pnu/lk2L4roRuvmy/CD0cXENiVE0wRKIQkIUUOL6\nEjkF4/E4M2HOC6tBb4CsyMRJhKmbnJ2eslJvIKUJgeuhG1+78Q3DIEpi9g/2SdOUx48f4fkumq5y\n7epVDg4PkEhJ0oTbt2/z5ZdfUiwWuffgPs1WK7s+LRNVzvZBv/jiixyfnOL7HnvPdjg5OaZYKrCy\ntoKiKkiKjKJqXL/+IjPHwVA1ZE3l0uUtfNehUangex61RgPXd7HseVJbmIGE7wX8t//Nf0BXNNIk\nJF+0eP58h7X1DRTdYDAcMZ3O2NzYWFxXytyAKBim6XSCP5dgKuUK1WqFfMFmNOozc2ZUKlXa7Ta9\n83PCMHt952dd0iSh3Woz7o+4f+8+o/EYd+bRaa9QqdZwHYfZbMr62jof/OIXrHRWePjgMXGYols2\nk6mDnSvQ7nS4OD3n4OCAZrPBeDxiPBzhewH1dptarYaUxlRKJTw/4OqVa/heQK93vvgct9ttdvd2\nkZQsQTLL+sgc8L3eOePJhEa9OZ/A0WnPmRTP9ZnOhiiKhK4baKrJwwdPefDgCX/2Z/+ecrlAs1Wj\ne3HBxfkQy7Jptxs4kzGlYolKpQgx5C2L7tkppPGchXGolss4U4dqY5XxxCGYb1YrF/O8eONG5o2S\nJM5Oz7BsE9PUuPHCC9z98j6bG5tUqxXOz8+ZTV3+1Xe+zXgyQlUNzi8G5IslSsUyM8/j5VdexbTy\njMbj+aiczsrKCo2t27/7AP7xT//8/UGvx0qnzWQ2xHM9jvafc352iqZoIEncf/yIGJWpH1Ko1Ikl\nmX/+xS957bVXeeXWi7z15m06rRrraxu8+63fJ5FVOo0GvjNjbaWDbmpcvXGZTqfD0bM9Dg4PkOUs\n/7nTbGFaJi+//DJ//Md/xIcf/jN/8Rd/QZIkvPnmGxwdHRJHKffv3+Ptt9/k0aNHlEtV/MDD1HT8\nwGVltUO+UGDmODze2SFfqhIDbuDjBx6WnSeJQVE0xuMpmqqjahqlWpmcYTMajyiVilSrFdIkwZvn\nmOumjud4eJ63cG4LABRjOcvgIFzbwpAlSdLC8CRAToA5sPhbzI+bprkAIvF/QscUQCq6N/E7BXWu\nqgppCpIkI0lfG7lEFzadjRf6L5DtCJfV+fhYvABD4QRfHlcSxirx3JZTyQQzIF5/pqu5i65TdPSz\n2Wzx4RFUs0hmU1X1G8Ajzp8oFsTxxXMTjIQAVfE6RRSq0JuXR7B008Sa08dxGBH62XIH0zQJg8xU\nlaRZF2yZJrLy9Ya0ZZe9OB+/HQUrqGTxHgqjn+iuRSE1mUy+oYeLhRZCMxQFg3gt4voROr4ogpYD\na3zfp1arLcBaFALLhY8oFJcz3RVF4fj4mFarlclIlQqe67LaarG5tka9WsU2TCbTMcPhkN3d3Wys\nMAxptdsMh0NkGarVClEUcnR8hO+5aIpCs9ng0aOnPH26w8pKh0KpyM7uU+q1Kk8ePuLtt96hs7LC\n06e7bF++zPr6GooiZYC2vkIY+UzdCYahY5k29XoTRdUxdZUgChgO+4wuLjB1nThOuej3sIolVlfX\nMDSNg4MD8oUi+88P+au//Cu+unuPeqPKZ3c/5oUXbpDL5RkNJ4CEZedJkyw7odFocHR8yHQ85tKl\nS5yfn2PqBlGYsVfj8RDD0pA1CT90cJ0Z7U6L8WhMLmdz5+OPSeKINE5oNZo8efQEz/P56Fcfcf36\nDZzZjNXOKuf9C1zP4dmzZ3z66R2q1Rq1apPDgyNyuSJBlGAXChRLFcbDIc50hm1aSLLMefcMd+bg\nuB6oKnEa4cymzMZZnO5wOOTi4oLpbMKNGzeo1+uMRiNOuyeYpkl/0GdtfZ1ioUgUBRSLBWRFpVqp\nIcsKnc4KYRgwc7JFLX7oEsURqytrzKYBYQjra1usrrZRNZnzwTmWZaMoJrVaHdedMJkMaNaaxFFI\nGkcU8wXy+ewzY2oG08kUyzDY2dmn0lljNMlCa1xnysnxAXIsocoKz/f3ydkWL792i3whx8xxeLaz\nv5C5giCgUW+ystrBskwuX3mBOE3YPzym2eowcz1kVSNJJIqlAsViceFB2Xjh3d99AP/kx3/5vqQp\nDEYOTx8cEvgxe0c9Xnrz97nz5ROOzoY4bsrh4SkPHz6GFFY3tri0uUWpUCaKE8ajGfliFStf4Nmz\nPSq5HM16ke3tdX76jz+nU7vEJ7+8y+ef3+W4e8zp+RHvvfcdojilWK7RaHb40Y/+nt/c+YwH9x7S\n6bRpNluMxxM++ugjTk+Pee9b79Hr9ZlOXKr1KjdubTGY9NAMm5OzPsVaHd3MoRg2umkzc33iKIJU\nIolBliR834M0Jgi8LLM3X2Q8HlGrVomCCFWWMXQDXTNQVR1FUkgTiWajlemxQUiapIxGY6IoS3WT\nFXkx7y2ARYAMsOiKRDUvzdPeTMvCDwLiJJmnRWXBBQIwBEiKLlccV9DDy9p09ruyTj0lxTB1oigg\nJSElWwsrNHYBGpqmZcalOcMgQFNovKKbFMAKmQtb0Mnu3JG8PCstNogBCzmh3+8vqHld17Oc5Dmw\nyLL8/3K3Q0KcZnvWNd0kThJkRSVFIk4yN+vy6lVZlknIdnlJsowky0RxDJKUfY8M+HPzBLYwDFFU\nhVQCVdeYzKbkCvlsCYbvI8kS8ZzeFm5wwXQIFkYYxQQ7sjwnLmbjlw1u4v/h60AZQYEL8BSeB5Fq\nZlnWQvMWoC7OvXivBCALGl78LlEMBvOZaeEZEAWlaZqcnp7OZaMxpXIR1TAYTac0G00O955zY3sb\nVVWw8xYbl7YymrlYQDMNDNNE10wsy8Yyc1xc9Hn9tTfZ2dljNJ7SXlnDsGzOzs65eu06hWKJ4WDE\n//Hnf0mrtcKtV17l7v17PNvfZ2Njg5///J84ODjgxo1rvPzqKwwHPa5ev0GcgCJr6LrJ4OIi29QX\nRfR6A5q1GkEYUK7kOe+f4LlTdElBk1U0RWY8GnJ23qWQt5GJadbLKKrEH3z3exwcHvP5F3f59r/6\nVzRbbUrFMidnJ6RJyvnZGaAQRjE7uzuZe7pcYTgeoOkyxYLJdOYQBSG2kaPZanJ0dMxolC1nuXLl\nOrlChcHIwY8jPvr4U+5+9YAf/Mm/4er1a+w92+WV268wHAwYj8aUK2XWVzfI2XlyuRyNRoPffPob\nrly7AqlErVJjPB7TXmkjKzK1ao3+YEKlUmXsOVTrrSyRUVMg9JmMz+l3zzA0mUBKeeWNN5Bkmf39\nZ+TNPJapUC3mqRTLhGGMZho02xvoc9YhlzOBhH6/h6ZmUdmypBCFCZ7nMx6PkOSI6y9c4v69r1hf\n28QPPNZW1sibOpNRH1PRmIzHSHFIuWzjeVOm3hTXC4lTieFsytRzsYqFbDTQ97h+5RJPHz/i4uyU\nVr3BZDalXC5QLNhMZmM67XWKxQqf3/2SUqHIjRs3+MUvPqBUKYMkoxg2H392l1RRuBiMkFSD9Y1t\ndvb2iVMoV4oU59d7NlOesHrtrd99AP/L/+1/eX//8JzPv3jKyemY09Mznp0eceXGSwxch48/vYOs\nZjeR27dvs7W2zmww5Nu/920kSWI0GDKZTCmXK+RyeZyZS7lcYeZMSVJ49OgRYRTyws0XMW2DZrtB\ntVpjOJ7x2WdfkACf3fmUL7+6B2lCLp+buzsjDg8PuXXrVka1Sind8y5JmlCt17DyJs/3DxhNZtx6\n+VUkSSFOJcbjKc58BEqWFeI4IpjPsJbL5UUHWimXiaKIcrm86FqSuX6s65mrOqOM/Xln6ZKm2TEl\niXn6nI9pGoxGo8U+6eUtU8Di/0QHLWans5ExE0nKburxXPcWne9gMFgAiG3b9Pv9ReckvgSQidle\n4WoWgC86UNHBCqq5WCx+I0GsXq8vgKVUKuF5Hr1eb+Eez7Lgv05NE8WIKCoEtSsAQ2jdgqpfXiIi\nHrdc6AgwzExjAZ4fEMfCP5CtZASw7Rxh4C+2bS2OP3/94hwsu63VpfAc0dEKV71gAsIwXAQBZYs6\n3IUjXIzoidctwNl13cW5F8WWeH+W59IFTS0YGFHYCdOZGFMTBYx4HwSQp2k63zqWvXfLz1+M+gmN\nfFnaEc9RnHshYVSrVUaj0aKTz+bKx6RI2XkMIo72n/P2668xm00ZXFywf3hAoVBY6Oqe51EuZRGq\nlUqF/f19XNelXq+Tz+d5+PAh3W4XwzRoNBv85s5vWFtfY2V1hYveBZ7vYZgm7777Lj/++39gPB7x\n6quvMJ1NSOKI7vk5SZIyGA2Ioojnu8+ykUDALlioikzgexQKFo1WncB3qdXqFPJ5VFVjOhlRq1dR\nZYU0iXnh2jX+/H//c269fIsgCPBchxdv3mJra5soSbLshiTGd10+/PBDNrcuMXMdfM8lTWJq5Sqx\nH1Kwcuzu7lKw8wRewGQ0plDKcXZ6SrVaxXE8XDek1V7H82DzUoeVlTVUTSeXs7FMg+svXCNKQp7u\n7LK6tsrq6hqynMXrHh0dYdoWRt7GcV1WOqvZdWCbDAcDjg4PqVaqqFq2svjpzh5Xr13n2tWrOJMx\nSRKjSimB66NrGi+9epte74Je7wLSlGK+yGTUn0t7FpKsEScpUZxw3j2lWCzS7/cIwxCxY302y3R4\nXc/2oF++vE0hX0RRVBRFJQh8Gq16xiL6Af1+nyROMA2TYqFEHGUMUxQlfPnlV2iGwebmJt1ul0aj\nMd/F7mDbFlsb66iqys2XXpjLagmdTofxdIJl5VBUlZ2nO7i9IYV8Hmc2IwVWtjZJVRWrmKdeqSOn\nEmvtVfK5PB//8tesdlYwdZPReMBoNKLf7+O6Llf/JcyB/6//83///tNn+xyf9tjYusTIO+ONd97i\ny0cPeetb71EoFMgXily/eo3vf+8PaNTqnHe72FYeQzcxDYNXX32NcqWMLCmsbayz8/QJuXyOH/7w\nh2iajGmqpMRM3RmXr9xgMJzydOcZDx4+pD8YUKvXmU2mrK6uYdkmB4eHdFY6fOf3v8PBwcHCmFMo\n2oRxRLlWQVZVVMPGcXzW1reYzlz6gyGmnWM0muL5AUigqtmNVayH1HWdtc4Ks9mMcrn8Dc1ZGH6i\nKCaOEyRJXnSPQv/Muk6dbDzLwve9RSTnsvYo3M8iRnUR2RmERFFWzQKEYZQVDEtGK/g6dGU5HhNY\ngIbjOAsQEvq6AEFgQbOLtC8BAOJ44gYvwF0UFcIdL7ZaCWe8OE8CeIQmu+xYX2YOluUFYfLTNO0b\nkayTyWShxYtFLJ7nk6SQz2fu7qwo8IA5New5i/MhZruNOW0u2ADg6+JgDqDA4hwKCUREtS6np4lr\nQBRIk8mEer3OdDpdAKFwoS/v5V4OSwHmW6W0b2jQy538sitedNbLJkHLshaLccS56ff7iFn4fr+/\nKIQEEyPytZf9GmK8TZj5PC+LzBQ5Baqq4nkzSuUqvX4f27AxFJXTw33WV9rs7e0Qw2KZinj+R0fH\nyHK2qKLdbi8K5Lt373L//n3+7M/+jHanyWeff0qcRMiSwne+8x0+//xzWq0WL7/8MvsHByBJ/OH3\nvkcuZ3NyesjFxQVxnL2ntVod1/PZ3NhAkiRWV9fYuLSBnTM5v+gSRQGT8RDf9ahUalz0ehCnpElE\nvV7D9zw++PnP+eKzz3jh2jV+8K//DWHgU683sjHRUlbQW3aOi+4Zp6cnrK+vU6s3cFyHrc0NGvUa\nlVIZ13HwPBcpTbi8fQXTtGk0m0RJShhGDAdDVF0hikJ2dp+wsr6KrMbMXI9Hjx7xx3/8A+I4ol6r\n0j0/ww88jk9PmUynyIrKk8dP0E2DII6oNuqkSUKxXMJzHWq1Gh/9+mMqpQrHRydUazWOjw7Z2NrA\nsCyIE8bDPmHgU8znkebXVAxUajWOjo4gTijni8RxQKvV5Pz8gly+SJTExEmKIjNn9pJ5MZIZ4YrF\nAo7jLj4Tk8kERclGZS3LxPUc4ihGm0szx8fHjMdT/u7vfsR3vvs9dnZ3cX2fBw8ekcvlGY6GbG1t\noSgK9UYjW80cRoS+N0+UC+ZeDQs/cNE0lXq1zkV/yGQ6pdPpUMjZpJKEkbPpDfropoHruGyubSCn\nKZ47ZXjeJWfqGLpCPmehKgorq53F5ziOY67e/hcA4GU7//7G1lWqtRaqpvFf/4f/iqvXX+L6lVd4\n8tkXXFpZZ63VIfIDTo6OufPppxRLJXpnZ3jODCQ4Pjqke3aGZmj0B30Cz2MynfDaq6+yvvb/cPdm\nTZLc2ZXfz/dwj3CPfcs9qzJrAWoDUGg00A2SzWkjaWJTpEZ80IM4JplJoh71oA+AZ5nmQW+ijJRm\nOBI1ZtQMqRHZZBPsRi/objSWQhVqz6rKfYt9Xz3cXQ8ef6+okb4ApsxgBquszIhw9/zfe84959wy\nv/btdxiOe1QqDZ4+3uVvv/8haswgncnwxq2bNBsNsukMBwdHpJI2N65f5+GD++Tz+ciwrygKpeUU\n21e2OTo5wQ9M2u0xvq9xdtag1W0zGLu4PniEFKyh63jeLJr7OY4TiuYcJ0JaogiJrlMEXQhVN7yk\nPePxeIQkw2AWDV3XXlGJO44TNRypVCpSeLuuS783mC8CUSOLUkhrzwj8l+slxcEqqGwIEZsogqKI\nj8fjV6xniwVYeLoFBS5+AZvNZoT0RPSs2C0tUOeizWk4t6SIIgNEc9tFVbbQCAiaXhRzQR0LlC6K\njbjGEBbpV1CuF+DNhYOqqtLv95hO59u2/NB6l8lkIjFXdz5HF3Yx0cQoioI3R/xiDiyaOPFLvLgv\nfTGhTHxd0Py2bUfXQtyDl03HOPLALwb1LKq/xTVJpVIMBoMIRYuGR7wP8fqLyvJ+vx/tgRfoXLAW\nokGq1Wqhb3chInexgRTsh2BESqVSqINQFIyYgiQryJKOFTM52t9D9mesrC5j6Bq5YpGdnR00TaNa\nraKqKpYVj6j6WCxGPB7nwYMH3L59m9u3b7O/v0+z0SJuJYgZ5jzIxn4lPvb111/n/OyMXrfD06dP\neP31q3S7XQbDAVY8ztr6OuNhqKfIpNKcVyrsHe7RbneIW3FKxSXKxVV8T0JCoV6rk0wlUee7HAaj\nIe+88y6SrJDLZDmtnIYLZsYTCsUin33+GWbMZLlc4ocf/oCnjx9z7fVr6DGTRCJJv9dh5k7xlYBc\nPkcQeKyur+IGHpIic3h6wnQ6wvenJCyDQiaNHTe4/eYNes0m5fUlSvkiFze3SNkO7nTC3ovnqApk\nM1lG4yG1So1SoUw+n2fm+gQypNMpti9fxp1N0BSNVrNDp9Vj6+I2pjDZ0P0AACAASURBVGUxnY5Z\n21jh9OSQfD7LqN9jPB5Rb1TYOzwMx4/9PqXVZZqdNsVCgeFwyNnhCblcmqk7ZeJ6+D7IqsKDh4+4\ntL1Ff9Alnogzc11SqRTdbpfT01MsK86LFy9Ip9Ocn59jWjE8f0a702F9Y512q002m+Xp06dcu3YN\nTdX59V//DpVKnbOzCsPhDFXV0HSNb33rm9RqVZ4+3SGbzWJZFp1mA9/zOD09Jp1JMZyM8GYujUYD\ngEajiTFH4M+ePefS5W32jw9QNZ18qYCu6cymM/Z3X9Bv1PAnQ4rpBJoyI/BGWHEDWVNoNtukUil2\ndnaQZZmrb3/361/Af/DX/8cH/sylkC3Sqndpd9ocHuyxVCrhOA6Pnzym2WhyfHSEbcWJGybdVhsr\nbpFOpxn2++TyeTY3N2m1W0wnE87Pzrl85XKoQpZkRsMB7VYXVY8hSQoXt7aQZZk3b7/Fp7/6hHqt\nhmnEOD05JptJ8tlnn/KHf/iH/PKTTygWixQKBYJAotKoMJnOSKWy1OoddN1kMByHSFuTMWImg/EE\nnwBZUUjG46TSyQiZiuIxmxdOWQ5FX6LgxuPxSIQkkIaYMYrDFIjQ3mQyJgj86OAWNKr4d0JgJYRO\nvh/gzmaRyEwUXkWR8eaHvihAQjglDn8hnArmISOCrhV+3sXCHlJfg6ghEPSxQHPCfy4o+kXKXSA9\nMQYQwjFx6Oq6Hl1LgSwF0uv1ehGVLtTRAnUK+lcU0clkEtHWqqpG9K+iKFhWnP5cvBVeEx/Pm5FI\n2EwnoygkRiBha85ELAatiOZsOm/CIGw8Fhsscd3E14BIwS6K4KJYThRboapf3NMurscizS3U4+Ke\nifen63oUqyv0E0J/IObmouFaFNGJ4ifYByFwm06nZLPZ6D2LZyOdTjMYDKLGSuxQl2WZxnzRStiM\neiCpaLoWakGAmCojSQEXti7Q7fXIZrMR3a9pGqNhuA9caAXE51pbW2MymZBOp6nXG3Q6Ha5fvwGE\nwslWq0Wv18WKx3ix+5xOu83J0THZbIbj42N83yOXy+MHATMvbL5E012t1UimHMxYOHoyDYtGvYEd\nT+B73lx8NQnHBL1QeDccDBmPRuQyWfK5HL1ej/WNdY6OjjB0Fc+fMRz0eP3111BVBUPX8SUF13Mh\n8Ll4YRN8j9FgSKNaxU7Y7D3fo1gshvYuw+bs+Jx4zEHXDerVJnbC4cH9rxhOxjRqTfb3Dzk/PePk\n+Ihev8PxyTGXL10mkUjizNXSIUBIEHccRuMw5dCfzajXG8RjNs+fvyCXL/CrTz+l3Wpw4eImp2dH\nTOdMnu/PkFWZjz/+JZph8OTJY+JJByfpQBCQiMeRPcjkwxCs4WhCOp1l4k4JfECaMeiFivh6vR5l\nBYhNjNPplHK5zM9//nNKpRKtVot6o0mhUKBRbzCbubTbLWq1GsFcL/HRj39ErV7HMEzWNtaIJ0K7\nZjyeoNcdUKvXODw8RJtrV2RZwYxZTEYT0ukM1WoNSYaEk8R1fZKpFHt7exSWS1y6cpnj01MmwxGa\nqtGo1Nl/sUun3aeQyyErCqPhiEa7xeOd51TrTTY3N/n888+5cOECv/Vbv4Vkr3z9C/hXn/7sg/PT\nM/Blti5e5ZNffsagN+TFzgsePn1ETDcwdINKpcLy0hKBSOwahwghlUozc2dk83lm7oz19Q0K5SKS\nLPP9v/s7jFiMvb1DTCtBs9lCM3Q0XePk5BTTsnj65DHbW9v0u12+9e436fY6+L5PZ77v+frNGxwd\nn/Lk6RP0eJJsrsT+0RFW3KbarKPqCoHkh2tAfZ8AeV4kJZy4hSKBTxBZmrypO0e5kzklqmNZL6lo\neOnXFjTwYiEMD9YA3xce55feb3FYS5LEeDTBNGPR4etOw8No6rpoWliUQEKW52lh8ss89clkgm3b\nETUuaOrFJDjxn7AgLVLZQuQmrE3CQy0sJUKpLdK5xFYxMVMVaFmgSOGbFk2MQH+L6FsgSvHaiwVM\nqKyFrUuIrQSiFPadEAWH82gjZs0bqbARSafTDIfhSluRCy6aEW/OiAimQQTOAEwWdm0LdkCMEESB\nFnNuoSKHcG+2mGWLAi0scSInXhRmMVpZFKfJshyNOMQ1FTvIX2ogXo472u121AiK+aO4X+KZFAxG\nEARRYRY/Z1F3IZ5ZscpWeL7FcyqavE6nE77G1GXmB/iejyJLPLp/j2ajxlIppBw9P9yxLexw4XMT\novlms8mDBw/I5XKMx2NOTk5otVpIksTe3h5/8Ad/gGmafP7553z7/fcolYsgBRwdHYXPlmnh2OGG\nw2arwes3bpBJp0CSqNVr+BIkrDiNZjNsHJUARZGRFchmMhwdHrG6vMr52Qm7L56RSic5Pz+nVq2S\nSWcwDYOj/UOmc03B1HX5/Ms7XL5yCVkKaNQrjAchc+MHPvV6HdeXWF5ZIZtJo2sqnXYXVdFAlmi0\nWnS6fbqdHq12B0OP4ySSHB2dkHbSNBotPv/iC4rLJYbjCRvrm3TaHUbDAa12gwePHvDt99/H8wOe\n7jxla3ubwWDI+VmV0lKZfLFApVphPB7TbjdZX13nq68ekEg4ZLMZlpeXGQ37DIZ9er0OWxe2+Ore\nfXwv/H3//Mu7vHHjDTY3NzmvnLGxscmw36debTAeDHFSCTRNJZlK02638bwZyWSaTqtJrVaLNB2u\n66JqBpKkcO/ul1gxk+WlZWRJIpPOYBgW1UoFK54gn8uyv7/PysoK7Xab7cvbnJweU6tVeO36dU6O\nzlhZXWZv/wX1Rp2rV67QarUxDJ2VlRWMmIkRM0lYCXZ39/A8n7W1MBO91e1wdHTEZOaFzeFsyu7h\nPgknScKKMxqMyGdzfPSjjzBjceLpNHosRjqbZjQacOXqa6SzGRRJDTdAyjKddgeCgPzmfwA2si8+\n/sEHSGM63Rq7u8/I5rKkknECf0apWMCyTCQJMukMCcfmzt0vuX7zBtOJEHeNOTg4RFZU7n55j6nr\n0uy2OTk75cnO0zCGcDJlMBzz8S8+5vY7bzMdj/ECn7tf3uHmzZtMhyN0XUVTVZrtJqW5cGEynSIp\nGp7v0x+MSGXL9HoDVF3n7v37FEqFMN3IUBmPJiRsB3fmo2rhYZlNO2E8ofTS5uW5sznd/BJ1zWZh\nUY3FwnmpQDYCyYWHv4TnhfPqxUKHRBTKIZDzaDRCVcLYR+Fd1rSwGTDjVqTqluWXs2h1XhwEFR3u\n031pLRPoTCBy8UsmaHshZBI0ryimIofc9/2IchZCKlFAhe0JiKjmbDYbHt7RNXoZ5FKtVqOitihw\nExncwCtitkXkviieE689GAyi2Xy4ycmYX9cAdx4FKehod47exe5pWZbR582V2HgmqO0gCHDms3yB\nzAWVLRqhl+MQPbKuLQa3LC4nEcVTFGzBrIhwCPE6k8kkCqMRzEy/34+EaqLg/v9ZAsW1Fo2Y0F8o\nihJtERNNlbi/Av0mEonoOorZt2gmBNPgOA6dTic6rA3DYDjos7S0zHgSxgPHDQPPnXDl8mX6g150\nXUUTq6oqjUaTGzduUC6XUVU1sqMJ7/poNMJOJKjXKhwdHRL4HkeH+wwGXW7dvI7v+7z7zjs8ffqE\ndqtJq9Xin/zWd0Mb4nDA/QcPUA2DGzdvUMjlI5ucHlOo16vYVoJ6vYE5T+oyTZ18Lo07HbO/t0e7\n1SIRj+O7HifHRxRzOSaui26ZqKoceuFnEwh8TMOgUqvSaDWQUFhdv0DciqNIcHp8jG5ZdAd9hpMp\nhhWnOxiQyxXI5Qv0ehUsU8P3XPr9PqXyEoqmUVpZnYe2dAkCD8M0iJkxLm5dpN1t0+33yBeKqJqB\nF/jcuHGTSr1GrV4nkEFBIp1OkkqmmYxndLs9BoMhvV6Heq1GIAVc3r6IqcfZWN8knkgQACknSSKe\noJjLsXXpEgQSZsxEkWQcO4ntzNkl3aDb7WHFTWq1Oooi4zhOdI8DhG5jxvrKCiJdUfz+CstqpVoh\nEY/TXQiNkZUw9ro/6uF5Aal0Hm82pdGs4brTcHNjINHpdCkU88TMGLoRsoD3vvyKN998i08++RWD\n8ZDV1TU8z6dSrZLJZPB8n7/5q3/HarFMPGayfWGLL+58wcXXrtKbjFldXyWTdVB1BUn2mbojpuNx\n6F7xfO7du0ejUWdvb49vfvc//foX8Edf/uwDKZDZ2zvEdV3KpSKlcpFcMcv62ir7+3tIUphvW2/U\nUTUVkDDjFtVmg/NahVK5xGA4QtM1jk6OQZLZ2t6i1euQzGQYDMfohsk3332XRrOOpIAVj5PL5Snk\nwpSepG1Rr56SStssLS9hJpJc2L6MpBqMJi56zKQ/nTCaTpl54TxN1wxkSWY6mVPU3ozJaEAyYZFJ\n2rjjCd1uDzOmM51MUWUNw9Bx3QmmFWMynQDhpi7TjCFLYZFWFDlUps4RZxB4+IGHpmtAgKzIDIcj\ndEP7/6AfcTArsoY385lOZ0jIGEYM3/cYDYch6pZlJAL6vS72/OAV0aeieIicb2EJEtS5QIbi4BdF\nV8zpIZwrixmnQI9CiCa+V4wHhP1JzNmFd1jQ6sKXLmhrUYhFjrig2CGkSfv9PpZlMRgMos8iGIR6\nvR4VeVGYxGcNUfh8laki43thUlPcslAVmcD3otcRn13MuSUgZhgv6UJJYjgYoOsqsiwxc300/aWu\nQSD4zDx1Syj5RRMi2AMRwCL+iGLZ6XResi3zMcQiLS9oRyCMC87nI0uYoLIjBmFeaAEqlUoUaCPE\nZkDEeIj7bNt21CAINkZca0E7A1EjIK6vaMLEvw+dGQGe75GyHc4OD8kkHdzpFMOKMXFnTCZTuu0u\nw8GQXCpDoVAkm83S7rY4PT/jyuVLPH22Q3l1ia3LlymWSjTrDQxVo9vuUsznKeSyxBPaXGVexR0P\nkQl4sfec4/Nj0rk04/EEx7ZJ5zPceuMWhXyeytk5kiRxeHjEZDyjcl5lbXkVQ9dxx0NOjvfpdutk\nsg73v7rH1e1LzKZT4rrFa5dfp1FrhKOBYEbKSXHx9S36wy6//NlPiakqhqYy9UesXdymvLxCdzhk\nY2mVfqfL2dkZ/fGI4XhCLO4wC2SypTKaFoZWxWIapmGxt3+AEYtRKhe4c+dz3MCn1ulx+OwFmqLw\n//ztv+PSlUv0hgNypRJffHmXd7/5Hppu0On3MONxYgmLVqdDJp3l5PiUUi6L77ocHx7QqIcBKKOx\ny+raRSaeh66qZFJpXBQkzcSKh0VL1/TwPPED+u02X315l1KhSCqTRpJUWp0urWYT3/M4OToDz6eQ\nzzAYjMllCozGU4bTGYlkBivhoKHiuxMs08SOJxj0+iyVy/T6PfLFHIoiETAjm0tTqVaw4iaFfIl+\nb8CgM6ZQKtHt9NB0A0nVKJTLNBpNLMtk+8JFavUqqq5QqdSw7SSrq5u0Gl3ufnGPjQsX2T08YGV9\ng9tvvIE7txC+9/a72KZFu92mMx5Qr9cp5bIYjkkxl2AyHZPLZ5EVnck4bKym4yEpO8mPf/QTzis1\nSoVlvvHdP/j6F/C7v/jhB+PxOKS+8yVmM5+93d35QWXw4MFDyuUy9XqdZrPJ6soa9Xo9FMNoOrV6\nndFwiBkz+NZ779LptEnnMjx+8oSl0jIrS2s4iRSrSyu8++430GMatfoZk/EE33PZ2XmCOx1z6fIW\n6xtrDEehb/X4vIIZT3B2ds50NsV1ZzRaLbLZ0BcZj8dfsSIJ4VA+n4/mxTHdmBeLILRNSDKuO8U0\nY3heWLTEbFiSJPq9/pzifZkpbdvhQhNJDlGrUG6nUkl0XY+Uv4tzaF3X0VT9lcCWkG4ND2nP9yIU\nKmaqYk4JYXESoi6xPnIxpU2gMIG0er0eyWQSz/PodrsRfSyCZwRiE1S3QMSLiWdihisKVLvdfml9\nW0D+Yg4viu6iwlks3XAch1gshmVZ2LYdvX+hQRBFWBQ5e743ezHVTqjdQ5X0+JURh0C3ojkRSHSx\ngIn57mQS3u8AIkZBxJV6nhcVS+FNF6MCUaBFYyXGFWJGLSjtRU2CQOCyLEc74sV7FqyOGDsIZmNx\nk1ir1YoS/cRmtsWYWxH0IlgLTdOiQi2ocdEoiXuqqirdbhd4aRdcZEA0TaM3GKBrKtPJlMloyKDX\nQyKg2WriJJOsra0xHoSuB5+AnZ0dlpfLVKoVHty/T7PZ5PDgAMdJsrlxgRcvXjAZTfj45x+zsrxM\np9NFlmWWl5fZ3zvm9Picixcu8WznBUcnx/zRH/0z8rnC3KOvRsLTwWBAOp3mzp07FAoFzs/PmExG\nYYhMq8nlS9usLq+ytrbGwd4hs5kfUrzZHMl0luF4zIu9FwSKh6QAks/J4QEPvrxHPl0gl13mybPn\n5PIFEnaCRqNGNpvFSSY52D9A1hQ6vS5rK+vMZtP53nqNg4N9krbFZDzGNHVmrhcWql4PWZJpNVv8\n6tMvWCkX2N7eQjN0br1xC0WWaTWarKyssL62hq7r7O3u0u108D2PpJ1kPB5hmhbDfpcnTx7TbDbp\nD4dcunKVa9ffYObDoNtheblEq9XgwsZFjg+OqdcrxK1wza4ELC8v8xd/8X/yV3/9f3N4dMx0ErJN\n3V6Y4pbN5tjfPyCfL+CkU7juDB8fVdcpFEsMR0MURWY2m5J0UkhIVKs1bNvh0ZOnlJdKBIQCTtt2\nWF1dC0c/lk02m6Veb+C6M8azKalkhi/v3SWfzyHLEv1el0I+R3OeXz6eDNA0hVq1wvLKEnfufIHv\nz4hZMVbX11haXmbQ69PudHCSaYajPk8ePw7PeNOk3Wxx6dJlxrMptUaNVDKNKqvMRi66buDNAs4q\nFRTDpN7usbS2yeHpOb/9n/znX/8C/ld/8b9+kMnlSKezDIZDBoMxhwdH7DzdIZlMoioqGxubHB8d\nk81k+eqrryJBi+u66HPRzNbFi3z00Y8wzRizmYtpmSSTaYb9Mc+e7OAkbGq1M8AjEY+xubFOPpfh\n3W+8w3vvfpNer8fxySm6HsOImQSSTKVaQ1JChWy318OdIyShsBZzXVH8BPIRFihtjpwSiTggEW4I\nc0MLhGVG1O3LwBRjfgiLg9VkOByE4paYMbeSaRhGLFoQIChVMXcUB7nreq9EjYaRmiEdz9z7LWhv\nURCE2EuEgwhB0mg0imbdAkEJCnVxnirm3YLqhZdBMqJJyWazZDKZCJkJal5Q/6II2Lb9SqERqniB\n2MVoQdiwFlXmg8EgChAR6F0UbnHvBGsgKGIhFBOvId7TYoa3oOiEfUvcOxGXKq6PaAZEcwEvBYaK\nokTzY1HsZ7NZuHd5XjDFNRbMhWAchF9cfN+iqEwgaTH3Nk0zUvsLhkOSwh3vgjoXxVhYDkUu/Eu7\nohY1MED0PhZXkCaTyVeU7sJOKMRtQgvR7XajJnB3dzdqkkzTxJ15dDttZEkinXQo5XKkU0nKS2Uk\nWWZnZ4eYFj7HN2/eJBaLMRj0OTk9DT+HEePS5UvsHxyQyWT56KOPsBM2t27eZDgaIwWwu7eHYydZ\nWlqlkC+zu3uAnU5z7fXrPHn6mKOjI6rVKgDD4WjuPJhGowdN0+a/AwGNRoNcLoumaFTOz7l/7wGN\nepOMkyZfKtPtDTg+OSWQAma46JbOjTeuIqsSo2afZrXJZCTR7rr85Ce/IJB9Dg92UOfCTlVSyRXy\nDEdjuv2wOVZUjeEoBDpnx8eslIvg+wwGfVLpbFhYh6H/enNzk1QyzdVL26SS4S7s8SAUcKqKwsXN\niwwHQ1RFQ1V1DCPcGS7LMu50ymw6w04kyKTSSDLksllUXSOVztAZ9IipCraT4MmzJ5iGRTqV5vjo\nkHanyXg8Zml5CUM3aLXbbG9tsbe3h6IorK2tMXUnHJ0ccePWGwxHIw4OD1lbW8dJha6SmGkxHI9I\nZbMcHh+RdTLs7++G+xUUlWfPX3B+XuHS5cvEYgae55LJZKlWqxFIuXfvKwByuQy5YoF7d++xvLyE\naZrE4xaV8zNkSWJ9fYUHD76iXC6gqgrtdju0sCYT+IFPoVRCUVUkoFZrMhlPefzwEc1WnWQyiRW3\n0A2DWqVOuVyiUjlnqVgil0rz5OEjxsMxsiTz+Z07lJfX0Eyb5/vH7B6cclqp85/9F//t17+A/+W/\n+tMPTs7P2T86IpBkRqMpqyurlEolkskkw+EI152hKCpLS8tzj/QMGYVUOkmvF4pP/Kkb7suNW1hO\nHG/mUigUkAOPTNohk3HwvBn1eo2kk2RtZZWYYdDvDfj5L36J7wfU6k1kWUNWNQbjGQFhqlal3sAL\nAorFcOn8YDCILE+LnlrTsjDnqBpARppTlgN6vT627SDLEradmIvIiChgXdfnc2t9vl0sXMMJ3rww\nuvPX0QkCnyDw0bSXASXi4BeHsyS9XBQiCoKmhShKUZWowLquGzUcAkGK4iZ+lkDP/X6fRqNBJpOh\n3++H9ppMBs/zGA6HDEYjnGSSmefNk+fCJiudTkf0LRAVc/G5ReESamKBlOv1ejSXFfSwmPWLorGI\nnMXnFahRNDiL/nGh3BaFTjQ8qqpi23Y0rxUoUnxdzOZEwRZfWxTLSZJEt9t9JbNdWKuE8jpkVF6m\nlwk0L65Vp9OJir+YEYtoWDEyEAhY7NkOI0VfesnF2lggem+z2Syy7IkmS1DpEDIxzWYz+r0UzZFw\nEAhB46IlTGgfFhtJwUaI66RGTWwiagDENRazedtx6HQ7KJLExtoqZ8fH3P/qHrl8DsdxeP311znY\n26dULNLv9zk9PSafz3N2fka5XCSby5JI2NSaDTTd4NrrrzMYDsmm00ynLoosYxg6zXodVdM4PT2h\nUMhjOwksK0Y8ET7fb775JsY86ENVNDrdNqoaio+2t7fD1Lhkkk6ni6GbTMZjnu88o91qc3Fjg62t\nLQ729vnbv/lbxpMJ6VSamBVjOOxxcnpIrdbhfL/C3t4hf/lvfsAvPruLoiuoBqwvl1kql8mlc0xd\nj6PjEyRZIZ3NoBkG1WoNP5D58U9+ypu3bvLo0QNMM8bDh4/I5kuYVoJYzKLVbmMoKuNRl2rlnEQi\nTq/bQddD90sw1+MMR1PicZtKpRqKtVptjo9PMK04P/v4Y65cvcz6ygpnJ8ckEhYnJ0f0Bz2SjoMi\nq0y8KcPJEHc4pXJ6jiRL5MsFCELB4XA0IJvLcunyNm9/4zbIYDvhvm8kKC8tUas1yGRz2LZDvpBj\nb/cgzIGfhR50Qzf55//DP2d5ucyL3V1iMYtOp8v77/8aRsyg2+uwtbXN4eEhnufRbrcplUqMxkMU\nNczW37hwka/uf0WxWOLF/h6/9v630TWN1ZUlfvbTnzIYDPnsk19h6BbJVJpPPvkUTTfR1PCa7+0d\nslRepdlscXp6xs2btzg+OqBUKpHN53nyeIfxZEzKsWnUKvz0H3+EO57w/vvf4h//8R9IZ8MFNV4A\nxfIKn332OdvbV3nr9tvcfOfXvv4FPPBHHzTbLaauizvzqJxVefT4Aetr6/zsZz/FsiwePXqCpukM\nBv0QfU9HpJJJOt0uhVKRuGWRzeVYWV4il8vRqDe4fftNNBXcaY9vvHWNL774hPtf3WNt7SInRxX+\n+q++T73W5uHDZ5TKqzTbfUpL63QGY7rDMb3+AFlVkedpQTEjDvgR/Sd8xEIUlDAtxnPxkLC7eO5s\nbguKMZ26gIQx31IznU6ixRPiIO/N/cbj8QjXDXfrCmpeVTV838P3w4BOTTUICKJCLA57gaolSYl2\nVgukI1aSDoaDV1Dg4spKUYiEX3c8Hr8yIy2Xy3Q6HVQ1zPEeD0cosoyuaQRzQZw9R+ujUbj7VoTD\niNdatMUJtbJ4DdEYQbiyVdixAFqtVpQqJ4qGaZoRcyAoZLFYQ1D54rUXka2gjQUqFk2EoijRso1F\n+l6SpIjqFgVQzJ8FjSyK66LSfjQcY8ZM3Pn9j8VMxuNR9Oz0er3ocwi/tVC5i88tird4f6JAivtm\nmibpdDp634tqcGHn0zQtstkJxbvYeub7LzfQAa8sJxH/zrKsaPTQ7/cjn66wAHqeF/ngxT3NZrMR\nzS9EjCKNDoj+/tnTHa5cvsR4MmY8GjEej/gnv/kdppMJ/nSGZcSwTJO0Y7O+tkoqnaXXD5vi5dV1\nCvk8rU6H3/jOd/i3//avKBVLXFjfCGl+RSGVdjAMFVmZ4TOl22uQziSwTINet42iauHOadPk2fNd\nko4d6k48H13TSadSFAtF7t29iyyppFMpPM+n2WiwvLJCPp+jtFzi4cOHJB2b4XCAgsSVS5fpNDvE\nYybj3oRi4QL9sUutM+K93/gNyqs5/viP/xnffOcbJEyb4WBC/bzODInZLMAyLWqVKg8ePubS9iX2\ndve4cvUy7nTMeeUcfd6sNJotnu3uk0ynaDcbSLLPg/tf4VgO9VqdRrNFs9Hg0ePH/OqzX/H2O2/z\n6NFTTk9PyecLSJJMq9XCNE0uXLhAsZhnPOhj2+GZpKkSmq6STaeJxwx29g/CZS+Kxo9//GPeeeeb\nDIZ9vv/3f8f73/4WQRBwcn5OvlxA01WQJRwngZNMkslmmbgeaxubTGczYpZFMp2l3wlFaOPJBEVV\nOTs9JwCWy6vIEnznO79JNpcjk80Qs3TcmUun06VyXqVcLkXNZtigB9RqVUqlPF/e/Yrbt9/k+OQI\nfAnHTtNuNTk6POTyxcsU8yVWltf5h7//Mdev38b3De5/9YRrt26TL5Qp55cwYybdXofNzU0sy+K1\ny9dJJBI06lVuXn+NpaUyjWaLoxcH/NPf+32ePN3BlyBTyFIolxn0e3hTl/OzI9aXV8hn0xwf7PHu\nd3//61/A/+xP/qcPZjMX24pTPa1wdfsSq8srzNwJt27dAsL4UEWRWF9fZzods7V1keWlZfYP9nBd\nl6WlJZ7vPOPDf/whg+GAixcv0mq3abe7mLEYpyen3Pn8DktLqzx5+ozllVWa7Tam47C0uopsaMST\nDk92ntDu9ZAVBVWTcZwkmqYyGg5QNY2046ApKu5kylK5jDebpVtHGwAAIABJREFUYRqxcLf3eMLM\ndZElicD38dxZtOij1WpiGDEMI4aiyAyHAwxDjxCdsPcYhsFkOiEet4gn4piWyXQ6wfdFoVHRVG2e\nRDTBnbqhcj0ACYnJeII033LVbndeWSUa2qhClDcZT4jHE8SMcJGGO3WJGbFIsZ+IJ+j3+niejxkz\n6XV76LpB3IqHryXJGJqBTOid9NwZk/EEy7RIOik63W7oNZcVxvO/n3mziHLudruRclqgNIGSFynp\nf1+RDUSUr0B+QjEtCokofALFCnQrmpHFxSD9fj+a04sAnUWUKxClELoJdCyEYAL1CyQsxGidTidS\nlsuyMqeOdSQpLH4xIxYxKvF4PFLsC1QsqGnRyIgRgCiGwhInNrIpikK9Xo+QrWiUBFoul8vRyMH3\nfXK5HLFYLHq/YpQjBIjimovPIZgJ4csX10tQ5OPxmHQ6HX1dIG3x3sXiE+HJb7VaESL3PI/peIrt\n2NTrdQqFPDFDp16pUDk9xfc8Njc2aDfqTKdTjo6O0I0YO8+eUSqVuP3mW/z5n/8rLl+6TOWswutX\nX8MyYjx+/BhD1ajVaiwtLdNqNTDMsOnpdfvUq1UuXbqM46TodfrcunGLk7MTioUs3vxZ3dvbI5PJ\nsLu7y+7uLqlUCsPQqJyd0mm3KJfLLC8v0en2iJkmphWnP+izvLrCxa2LNOoNLl++xN7eHoaqkYgn\nWN9cZ331AjFdRfaH6Co8evCUvf09xsMx3U43TD77/FP2dl+QSWU4PNjHn83IpJOk0zayFNLa56en\nVKtnqLrGcDhAVzUkBU5Ozni+u8etW28y8wP29vfY39/n7PycYr7Au++9R7/fA3zUeW77ZDyiVqty\nYXONzz/7lO/+5m8wnk6wHYfxbEaAwgyZ6QxGkwmaqmOqKvu7B2xdvMjR0SH5XJ61tQ1kScUPAoy4\nie8FIRs3dWk0m5SXlpFljelsxngyplAsIcsaquzy7PkzSqUiXhD+3lpmDN8PePb0acgeTUfs7r5g\nOp2QSqVDNjCb5cXuHjPPZzJ1SWcyyLLKV/fvs7u7z2/8+q+Rchw6nR57e0c4TpJMJo0sBZyenpLN\nZfniy3vELItcsch5tcKbt9+m0W6gSDJSMGM6HWHaoec/kUhwXq8zdYdMB11GzSbeZMLq9jXW17f4\nxWefcnJWYTSa8A8/+JCtC1sM+kN+8IMfkM5nCICzSo1yeYlr73zn61/A//W/+F8+MHSN69euocoS\ns6nL06dPMAwN07Q4PT3FNGNsbW3x2Wefkc1mCPCoVqq8/Y23qdVqACiqwoXNC+HebnfK6VmF8XBC\nIp7kzmd3KJeXWF5ZQ1ZUOr0u61tbpLI52t0u05nLabWCooVLJjRDQ5vH9cmyhCwr+N4sms2KhRii\nAPm+j6HrmDGT6dx2JLKiJUnCcWwURQ0Ln6HPf6YURYbGYjGq1eortiExMw3RKpEoqN8fRruPQ/+4\nx2g0JghgPJ4Qi5n4fohsBMoU9G84T1exrASe5zMYDNE0Hc/z8TwfWVbCz+oHKIo6n8VPUVUtXBU6\nf51QmOEhSTKzaRhTqUgyAVIoApqLt0TT0m538APvlXQx8WdxbisiUBfjZYWSXRQgIXoT9jhRwMQc\nX/zsl/PnEOkJoZoozrquk8lkonm6eF2RQAa8kuImKH5xLQVFL+hy8bls20ZRlEil7Xlhk9Zqhbvf\n4/EEYpWisP0tsgW+70dJaLZtRzPlRcpZxJSKrwkBoZhNL4r/xPsTiF0I58TnEjvBxb2ZTqeRXUxo\nCkQwjGAAxLUQ2QaLdHuxWIy8/UCkwxBoXzAoAok3m01KhSKqqhB3HPb3dykXCvTaba5cuoSKRCGX\nDZkFWUHVVIqlMs1mk1yxSL1S42D/gFwuSy6XI5/LMZtMiRsmAUH0/k0jFtqFNINMOo+mKqRTGfb3\nDmi1u9y58yX5Ymb+Oy9Hvvrz83Nu3rxJKpWiXF7m9HiP4+NDvve973F0dMiXX97jP/re75GwkwxG\nQ+4+uMeFrQvUajX29vcgCFhdWSFhOxRySb7/d9/HUC2eP3pIxtGpVM6p1nooqkwum+XF8+cYpsmD\nBw9wHIe333qTH374jzSbTf6r//q/BEI7nKHp87WiMabuNPydn4+TPv7ZL3jzrW+gzf3Ip6dn/Pbv\n/DaKorCyukQhn0OVFUzDYO/FC167coW9Fy94+/YbqIqMGdPxpi6Hx0fMCKg12hSWVghQkRWTXC4N\nrsfZ0Qnb21uUl5eZTqY4iQS93pDz83PSuTx2MkFvMEBCYjbzUBSZ6WRGJpfj4OAAK2Ez6PfDJnfS\npd/vzrcsakiKzM8//jmaqnFxfZPD430MQ+eXv/wlw+GQGzeuU62G60odO4UsK8RiJnErgaKG0dWJ\nhM3GxjpPnj7CtlM0mx0uXLjI+fkphh5acPuDPlYywevXr2GnkiCDGbe4c+cL1teWSTk2nu/iI/Hw\n/kM6rS5yXKNSOeXt61d48OlnEMD/+Cf/G4puc/XGNYrlMof7R1zeusLZ6Xko3pUkTNsgkyvi+xLf\n//sP+cM/+uOvfwG/98WnH8RNm3t3H1A5q2HbNpPJmOvXr9HrdxgMethOgoOjAwJ8Uqkkn332Od1O\nl/29vTCSsROizVKxiBNPUKnV2VhZpVwqUa9XuHDxIkdHZxwcn1CrNlFjMVLp9HzOJNHpdhj0+2i6\njqJpyJJKTI9hGibdXi/atyzocjGrFTQowMwLZ8sibWs8HpPL5SIvYziXneH7If1qxsyooHa73Uh0\nBERzV1EUfD9A0wza7U4kWPM8F03TI3Qm1Ofiz2ICm6CPNS1EhOLgBiKLz2QyifKmhbpYKO0F0hV2\nrdk0pME15WUAymS+67k/GCDJL3dfy7KMTHhg+/O5/yvLVebITsxap9NpiHSR6Xa69Af9qOguqtVD\nG9kYVVVw56MKISIUPnbTNKOfKUReQqC1KGQTM+ZFy5YQ1YlZvfi7xSZBFC+B5G3bptPpvBJao+vG\nfG5vRKK9fn9A0nHCbWyqSmI+dhFK88ibv/C6i3u4xT0S+7VbrVZE28PLpSfxuT9WsDv9fj8qpMIi\nJpD9Yrreop1N/DwhEhQNhxgRiHm74zgRfS8S78SCE/GexfVqt9sRa6EoCsNOj6k7I5l06PXauOMR\n3Vabt26+gaFrHBwfUqtU0TUNXdPI57KcnVd4+uQJxVKRN996E0WW+eSTT9B1nZSTZGNzgydPnqDr\nOk+fPsXzPbKZUJ1cr9fZ3TtC0wxsJ0m5XKZUKiBLEo6d5P79uyytrqBZJo1uG2PuIph4Uy5duUF3\nMOHS1WvsvNjn2bNdVlbX+Zf/4l/y6adfkEnlmAynTMcu5eIyqqzgOHEGvRbZQpbHD5+zs7NDo9XA\n9QMU1aDROMcyTRwnxdl5lbdu38ZJJMimMzx+/JRM2mZzc531CxuomspoOKE3HBBIoEgqhmkyHI74\n2U9+hhmLs729zerGBuNun9FwxLNnz0lYcWzbZHVtJUwonLi0mk22trcjAaYX+Mw8j8FwxO7THbqd\nHkknjaSrOMkUuqajSgGGGp4Hz3aecevWG5ycHCMpCv3hkF63Q6NW540332QaBHiTKf12B8OM4Xk+\n+WKB+/fvMxqNMeZgpd1p4Xc7DHpD+u0ha8trnB4dUT2rcOniawwHLo1aC8dOIiFRKhVZKi8ReBKB\nF5DJZhkMBpyfnyPJIWA5PDxAkiSWl1fpdjpcuLjFZ59/ia4bdLsdrLhJTNNwbJvRdEK+WCJhxum0\nu3gzj0Gvz8H+AUk7QbPT5OT0hGIxh4THcnmD88MTLmxs8vDpY/73f/1v6A09JrMRvVaD4bBHoZQn\nYBYu5Gk2ee21K1RqNXLpHMtLK9i2w+33f+frX8D//M/+5w/ufnmX8WhMIp7gwuYF0plQkRua/OfW\nCtvm9ltvoWkaqVSK7/3e9/CDMOGp3++zvb3N2uoqf/pnf8Ybb73B5atXuHf/K6azGZOZx/qFC4xd\nj6XVNZZWVjir1MKHyIjhuj7l5RUmkzGqElKx03Go6IyZZjQPFgVCKHuFvUccXOKAWqSAxZxQICvP\nCwv4eBIirJOTExzHoVgsRoIscTiLwhv4QYTkRPGIxUzq9XpEQ4riIwqcKGSL+6oFghJfF4e0+Htx\nOC/OW8Xfi9mvrus06o2wqGr6K0pjSZIYDIeYlhnNqCFsbjxvFlnhxMHveWFe+7+f9hUEAePJmFw+\nF81sF5G5UIlblomq6hFSXtzfLdTmizni4qASKFLcS+F1F6lti/5zkT8viv6iYEvMcEXjJctypBIf\nDAZz/70xv6ZhutlLmltiNBqiz+9pu92Oiviip1poGgSVP5vNooxx4RYQ44fFrWtCPS7Eg0KEJjQa\nQr3fbDajiFvxeuJ5Fg1LLBaL0uwE4ySeCaEwXxSuiZ8nFOq9Xi8acQwGg+hai9Wikg+ZXI7xdIyi\nSOiKwtnxCYNeFzueQNVUPvv0U44Oj7Asi0w2yw8/+ohUKhWNZHq9HscHh1y9coXTuTr97OwsYnds\nO9wUFouZNJsNdN2g1Wpx+/ZtDMPg0aOHyIrE48ePse04M9+jNxhQKBaZTibUa7VQ6X54RKFU5Oz8\nnHqjgS/BjZs3MeIxNjY3GQz6JBIJxuMR/swj8D2GwwFbl7b4/PNPGQ6nEEihd7hYRlGVMFbVCPPT\n0+kUT3ceUiwWSCYdHj16xK1bb3Hz5hs4TprdZ3usr66jSgq1Sg0naTMYDUGScZIpUqkMiUQCO5ki\nYVo8f/6cUqnE82c7LK+USdg27XabwIduv0cmkwn3Wnszjo9PGA5H7O3tUzmrMp26FFdWSGXyOMkk\n1UoNJ2HT7XTCRUyKjB/4NBoNyqUSo+Ew9DxPJrx+/TpGPM7p0SF379whl88h+bC2ts7B4QFBAFeu\nXAmDmCyLuCJTqdZRVZ1ut8fJ6Rkz18c0bXrjAa1uB0lRWV/bxDRt4gmH7rBLKpvBnUw5OTlBksLV\ny4NBmAPR63XngUtgxGI8efocz/Nx7Di+P2O5uEwQSOiWiW4YTKYulfMzBoMeGxe2iek6pmnx4vk+\nV1+7jucGKLKOk3GoVc95+PAhiiqzcWGb3/nef4xqyNhWApAolgp02h3csUvMNJAVCSnwyKUzEEjk\nsjk2r33z61/A//v/7r/5wIxpfO97v4sdtzg/P6Hb7TAeD+fpZLEot1qWZZ49e8a3vvUtGs0mu7u7\nNJpNYrEYN2/e5OOf/5zNjQ1OT07DTWPNJssrq3z6+ZdkCyVicYdKrYGimTQbLRRZRyLc5yzLKiCH\nCkYlzCRW5DAj17KsSJQjqELLsqIsbUFvCvWz+CMO4sU1jSEK99G08IBMJBKvfK/wSi9asiBMDRIq\nbiCyeQGRTUyW5WjOKwRFAnEuFnVxEIs563A4jGhbMdu1bTtSGy+q0X3fR1XCgjEajiLmYDqdhoez\naYZLsOd/hLBMVRUGw0H0cwXiFmht0RMvGhlRaIRyezQaRZ7ikJ1QIi+5QIRClCWYBdH0iMIv5s3w\n0gMvGhwgUtcLK5yILhWIftEuJb5HWMHE2ENcQ8OIzal9KWoKRESqMY/0FaEngvUQLIcongIVi88t\nKG7hl7csK8o2Hw6Hc6tMPMoLEPdGXCPBDDiOEzUxokEQqF8E6ghv+nA4ZDAY0Gw2w730rhvpGESD\nJWbgYpQhvk/Q9eI5EOtzRWNoGAbj/pBaMyxGrjsl7TicHh0z7PcpFYoocvj82Y5DwrapVqu8+cab\nJKw4H/3wR6ScJGenp7z33nt4nkejEWag37hxg08++YTLly/TaDTZ2Nik2WwRi1msr6/Rm2est9tt\n7t//ilKpyOrqMrPA5/qNG+TzBR49ekQxX+Dq1atoqsbMm2FZJqmkgyJLbG9vUa1WyOfzLC0vYxo6\nQTCDefLetevX5m6XHmdnxwS+wieffMp4PGVlZRVv7qqp15skEuF47vjkkHQ6Tbvd5datW1TOKtx6\n603UmE611SCbSvLk4UPcyYTBaEgmncH1POrNFhtrG5ydn/Pprz5lY22NRqPB4eEh733rPVrtBs+e\nPQvPBqQIXOzv77O2sc7p6TmZTJb19Q1uvn6Lfm9Io9UmncthxeP0ez2G/QHanOGpVirAyywBTdNY\nWlpiPBljxRM8ffGMrc0LGKrGyfkpSdtmMBzTbL10TTSbTc7Oz9l58BiQGU/c0IUjK0xdj25viB94\nvPvuu6RSSTK5LIauoSgS/W4X3/Oo1WrIshy5LCzLxHEcPvzwQ5LpLF98/hn5bIF0Oks8kWBjfQ3f\nnTGbTnCSNl/cvYuqKAxHY7747A6yrPDatat0Wi0C3yflJPnyzl0uX7pMPJEg4cQ5P63S7fS4dOU1\nMrkyheIyuVya/f0jbt64QdyKY86dRd12i+cvnnHt9Uu0Ox3S6SztZoerb/8HsI1sc9X54NL2BX70\nww+5duMqy+UiyaSFqkqkUimSSYd0OoUyF4fduHmDQqHIwUFIkcQMg3Qyxd7uLvt7e9y4cYNeu8Ot\nGzex4gkkSWFlbZ2zsyqSpCKrKl/c+4pcNoehG9Gh2+q0CSSIxQzkALLZLKl0Oipeth1nMnm5/1gc\n4uLBFahboDthkRLCIHEIj0YCKb8MWBE2LXFYw8tEtRBRh3NpMScVSt/FRSCC+hQodHEzl8g3X0RX\nQLQtTIRyCHW5mPGLQi+oU/HZs5lM+L7m708UTJH1LMnSK2gsLIJhYZ9Op1FWtaB6xWftdrvR7DRU\neA8BKSpktm2/oppeDGcRDYG4NqL4CPQsBIODwYBBf0ginsCdheIqUVAE6hWzYFEgBRshAl0EoyKu\noSjeAolLkhSKdyKhXnjvTk9PsW17PkIATXu5kUx87+KWNyB6psR9FiEwIhNAjFHg5fNUqVSihkiw\nKqKRHI/HpFKp6L0L+5yIvI1bCRQlpMhd1yWXy0WJbuJZF82IuHei6dB1PWIHRFMgnA5ia5h4TsUz\n1Ww2iak6yBKyEj57/U6Xyukpl7e2eO/dd2nW6zzd2QFCEePx8TGqrJJ0HJ4/e8bv/Pbv4Ng2mXSG\nwbwZFSOXq1evsrOzg23bXNi8yF/+5f/F2uoaqqqSSNg8fvyI9fV1Ll3a5s6dz7BiJrl8lr29/VBs\nZ1l88fnnxC0LyzRRvBm1yjn7L55TyGZxxyMa1SoxTeNnP/6IfD5LqVQgm0mSSSdxp1OazTrtVgfL\nitFotGk2G6RTWUqlEtVqjbtf3uWb33yfS9tXOT+rYFphU/R7v/f7/OLnn/D27Td58OA+X355h1I+\ny4udHf70z/6E8lIRx0mh6THuP3zERz/+CZ4fUK/VeO+9b+EkbFZXV7lx4wbVaoVur02326FYLGEn\nHJ4/f45lWVy6egXfD4N2UqkU3U6f2WRKvljg5htv4AUeBwcHXL1yZZ44GD4bteo5qiyjqFp0nu88\nf46dSNDr9zk9P6Pf7bK2vsbS8goxLfSG9/p92u027XabuG1zcHDAxtIKDx4+pNZs0u51SdhJ6s0W\nv/jVJ9y6dp2lUp52q4oZk1GUGdXqGTN3xqg/pD8ckEgkcByHs7MzHj96EtoKq3WuXb+JIskUCiX6\ngyF2IsHJ6TGOnaDbbaDqCqenZ6TTeZZKy0wnHqqi4U7DnfNJO8mD+w8YjUc8f/6cdDrNw/uPeOON\n23z0o4/JZIrcv/+E167doNWqcXH7Ii+eP6fX61GrVMikMyhywMXtTT786EMStk2z3eG8UuNbv/VP\nv/4F/JOf/s0H/X6P2WzG7dtvcXiwT6lcplgo0u12mM1cVpaXWFld5vjkiHK5xMc//zn9Xp9//IcP\nef/b3w47vKNjbt28SX845M3bt9k/OkJSNexUlm5vQK3VZjSeICkKHhLZTDqk1zwP152gmwa2nSCV\nSuHPvGirlbAyjccjBvM0KOCVmbNAcELJLIqaKKDAAo1uz/8/nG/rmoHnhaKv2cxDVbU5wg0R5syd\nzdGkGQmuBDoTh+d4PH6FBtY0DVlTCSSYed4iII6odBFAI2jixQ1YokBqmhYlmSWTyWh0MJlOCfwA\nRVWYLQigNGNuoTJj80UFYruXxWzm4rozgsCnVCqFTUQgoWk6k2mICs2YhSzJYXJZEBAEREV3cRGG\noPiFMEug436/H7EdIulNMBwCnfYGgyiP3g/8qMgu0sZhupPNdBKK0CbjCbH5e4oZJp7no8gK3sxj\nNvNIJlMoispoHDZEhh6L2JHw54Y+ftOMIcsS/X4vROPjUVSghU9dhNksppWJeyEseQJRu+4sauJm\nroeEFC4EUVQ83yOTyURFWmxmE/N5gZLF2GUwGJCI23MVuRY9T2JMJD6LyFMXIyORGJfL5aIwnEWF\n/uLvgbCvTSYTWq0WnufRbDYxNQNNN6jWq8iyxHQ0IpjNSCYSEASMhgPSmXD5xe/+7u/ieR6Vao1y\nqczNmzd59uwZ5eUl6o06Ozs7dLtd3v+NX+fJo8fRqOPg4IDp1OXGjRths9rtcHp6ytraOv8vd28W\nI0l+3/l9IiMjIu87s+776Puce0gOh0OJlEguZUriWivJXsO7L/YuYBtYLPxkjAV4AcMGDPhp4d31\naiXBkHctcUlRJEVxZkhOc46e7pm+u6q77rvyviIzrozwQ+Q/Olv2i+EHm2qg0dWoqjwiIuP3+31/\n38OVPBLJBI8e3mdvf4/FxQUq5TJW3yTkwdmVVY72D3Asm2hUZWJ8jFKxwNrjR6yvPSYe05gaH2Os\nWKDX71CvlGm16hRyWe7f+QzJ8xjYFi4DjL5NpVLBMAw6nS6pVIrJySmSycSQXZ3i6GSf3/7t3+bo\n6JhqpYrtOLz3znv02zqNcp3joyPOXb7C2UsXmJ2YpVqrkcxkuHb9BeZnZ4bXY4in62uYpoFpGlSr\nZSYmx7l+/Rq2bTM3t8DJyYlvUBOLkyvk2N8/IJ/Pc/PjT7Ati7mFWXpGj2wmDRL0u13K5VOSyQRb\nW5tUyxVUTcW2HU4rVVwvxINHD1heWKJar2G7AwqZHIeHh5iOjdHVicSiFIpFJqencWyb8xcusbOz\ny/TUBF/7xtfJ5DMcnx4zMTONqmlMTE1w7eolOnqbbC6NbvZoNhu8997PfEa75JtceZ7H9vY2oVCI\narVKPp/n4sWLlMbHiagqqqpx78E97t27SyIaQ1HCPH68RqvVQe8bHB7sE5IkJsbHOTo6oHxU5vjw\nmGKxxNMn6ywszLC2tsbhwSHRqMLJUZm9/SMWFxd4+nSDf/un/xunxwckUjGOjg/pdlt+ZvrMNPt7\nu5RPjymWCvR0k1ajxcrKKhde+VsQJ/o//4//7O3JiRm+/NavYho2czPzrK8/5eSkzPqTdSKa5qfB\n9PpENA0P2Nrd5Wj/yJ/MkLh39y7XX3gBV5LYPzjCUWR0y0E3bVq6zvbhIcWJSXSjj+X4EFhUixCW\nJRzHpmf0SSWSuPiQaC6fx8Vj4Lk0Wy2fVW3ZhENy8LrFlCQ01mKnKNKh4vE4zWYzKHzCFSyRSAZ2\nhZHIM42smL7Fzz5vjRkOpptRC1HbHUBIwjBNtEgELRJBDoexhxOh2Nlajj2cjEPEItHnGO6jTGox\n/Ys9uiieYtIVBVJVVWyRPT1w0CIa7rAxYMiuFvK4Z8xxmXg8hmVa+ClozyZLPEgmU8TjSTqdNqZp\noSjP8sgFqWrUpGXU+lUUDFVVyWXzuMOGyDQtHNvBsnxLQ33IFo9F47iu3yy53rMkMQF/J5NJJELD\n4xFClkMBy7VvmT6pSQLLsXHxcNwBkVgUy3aQQiG6PT93feC52GJ6jUXRohG6uk5YlonGIs85mAlb\nXIEyiD3+qLGOyCcW5jRCwlar1ofHSBvKDl2SiSSNRj3YM4v1ivg9MTGLBkaWZfAYar7jxOMJarU6\nfeN5L3xxbgXykEqlAj7DaA66WF+I8yNsYsXeXqTPeZ5HKpbAcmwc1yGVSnN8cMjc9Ax236Cn66Qz\nKWZmZpiZmaHX6/HZZ59hWTaxeJyHjx6RzqRZe/oExx0wNT3N9OwMtz/9lE6rFTgWxuNxVE3l9qe3\nabWatNttDg4OKE2M02jU+fGP/4qXXnmRa9ev0+v7cZpT45N02h2SqZSPDLQ7GAOHbk+no3eZX5pn\namqSyekJut02Hb3D7OQU9VqdyYkSzXqFWr3C4sIC/V4/IHBNT09z9uwZUqkUJyfHzM7OoKgSnU4T\nD5fllUVMq0e5fIqqKhztV4gkUrz59a+RmZrk7/7+73P12os0Gy0GjothmpQrFer1Bjtb277RVUgi\n5HloqkIiGWd6ZpJmp0VX7xBWwvS6BnPzM3i4xOJRHNsiqkVwLIdYNEKxUKBv6JiWia53aTcbtFt1\nwEdNTo+OUFUFxxngSTLbOwcUx6eYnp5gYNm0ux0mpyfptHx9eXGshKH3CCsKlm1zdHzM5YtXOClX\nKBZLeAOL01qFYqmIqmq47oDV1VWWlmZpdlpkcjnS2QKGDY6roERijI2Po8U0QniEQhKG0ScS1VAU\nlbGh6Y/jOkOy8xg/e+89Pvr4I65fvUq/32d364iBK5HNpNnZ2iISCRNRZaqVY7rtJq1WjWvXL1Nr\nnvArX36dsDTAtvrE4lHanS7NVp1MNsnVa5doNmp88+98lcOTQ+LxKK1Oxx8IHI/D/V1Ojo946foL\n2H2LTDKFNHC4/MY3fvkL+Ds/+PO3jw6PODk5YXp6EtMymZ6ZJqyGyaQKyCGVRDyJZdi0mh22d/YZ\nuBKapvDFN74IrsfqmTPsHR5y87M7LJ49y3GtweFxmU7XYOCCqkSxDYOIqpGOx1FkDRePfl8nk80E\n3tl230aNhIlGfdjUGU5lEQFHDycYAbWKnbCY2MTN1vM8OkP2urDpFFCin/YVo9vVcV0PSQrhw8S+\nPMuybMJh/4MRjyfwPIKdpyCSib20NmKKYdt2UDAFW1kUegHn9/t9Bp4bsJ5F4yCMN0YtQwVELEhY\nmqYF/uye55FMJdF7PZAkDMfy2dPD9w4Er0Hohf3iazEwkUd1AAAgAElEQVQYuLiuF8jg6vUGqVQa\n03To9fr0er7kSQI81w96EdCr8EgfjSkVN2fBaNe7fSQphKKoJJMpdH0ou1OUQGIXlmV/8jcNhD/8\naHRmSJKx7UHA/vcJfyr1eoNoLI4khWi3OySTKRTFT0bS9R5axLcFjUZjSJKPzITCIdSIhid5WMP9\nXN/oo2oaYdmXE/Z6fjjMqBZb+M2LYyey4kVxFCYyqqLhOC7FYgnHcYcqhTCVSpVo9Fk0ozBjGeVW\nCLKZJEk06s0hPK+iabHhusC/dvSeHqA14jyIHbnYwQulgiBJjnrHi/chOAi1Wi04lwCmbhJWVYrF\nIqenZfZ39shlMpweHZPPZtENnUhYpV6rs7m1SVvvYg0GJLJpkEPcuvMZ5y6c5+Hjx4TCMr/48ANe\nePFFDN3PCn/hhRdYW3tEOp0gmYyzvLzI1cvXSCRjKKrC0ckxF69eYm3tEclUCnNgc+PGDSzDZHll\nhYPjI3b2dnEch1bPJF8ooqgaqytn2N/bo9vo0Ot0mZuZY/3RI1zPo9VqsrW9zcTkBH/2f/x7pJBC\nRNOGTVqCnZ0tut0O2WwaVVOoVKpUynV03eTx4w0uXriKEo6wsbnHS6+/wFe//hXOnj3Dg3t3Wbt/\nn7/+4Q8Jy6BqcfAkjL6B0etzdmWVTCqNy4CIopBIxGm3W2xsrlMcy6OoIaJxP/Na13Wmp6fodjtD\nOWIKw+jhuR6XLl/kpFKm1+mSzaaYHBtDkWXGiiVWVhZ58cXr3PnsLmE1yvrmLjd+8Qmm7fL1r/8q\ntXKF8ukpxVKebqdDMhlHUkJMjJewBw6HJ0c4zoCIGmFgu4TDGgx8Vvy//853+Pxrr3H92nWatRq2\n0aV6dMT05CQbT9bIp1Ic7G2TTSVxDAPXtplfWMCyTDqdDlNTU/R6/aH01CQa0ygfnfLp7dtcuHSe\n3/39v8eff+fPUcIyk7NTqBGFZCzGF17/ArIUJp8uEglHsbsmX/nVr7K9u8vk1AT7mztYPRe9YbN4\n/hyxWJKTSoWvf+NrxBJRFuYW2draRg557Ozv8nv/8d9nanaBkKwwXpwkk8oiy2BafXL5BJGoxNlX\n/hYUcKtbefvKlStcuHCBsKJRbzY43D2gU2/hWRb7B/tsbm6SzOQ4rVSJJ5IUchmSiSTVWp2+aZLI\npIkmUxCSkUIKpuMHRrjegK7u2+rJsoztODiuR0gOE09E8FyXcDhENBobGtNHhjDkAL3XIx6L+TfQ\nIWEpNpwqBAlLSGYEzDiaTS3ytIFgyhV7XzHNiEZATPPi5jrKOE4OSTtqWMHoG8hhOSi0qUz6OZhY\nEK/Eflyw2QPDDMvy2cSmFUDpYlcpQixGG4RRdrpw+RIyJ2HYAeAOb+wChQCCAiNY5QKVGCXficLk\n5zr7zGDPGwwd5SwUNRxA8JqmUS6XA4hc7MrF+0okEr6Mq9mm1ergeW5wDGRZxh0eEx/xkOibfWKJ\nGHjuc/t4v4B6Q3RCRdjP+qsKn+07Sl4bRU6EvtyPT/WwrGfOfF29C94zIxpZkoZTgzFsbAbBDl9w\nFcRqRjy+WM2MoiUDx4foPQ+63WdBJYqioGpKYHIjfldou/3rVWEw8NO+/LAdHxL38wScIdxtABJy\nWA4aQsHxENwC8a8o5OJ8tNttarVaQFwT2nzT7BMKSZimP+0fHhyTyecwHYt0Ns305BTz09MYeoel\npTmMXh9JkXnt1Vd599138QZ+IE9YVZidnUULK3x6+zaFYpFYIs701BSVSoViqcTyygqH+wcoiooU\nljktV6hX67TbDTqdLgeHx2TTeZaXfDmVO3BJpbOMFUpEVJVMJkMyleLll1+mlCuwd3rE4cEBqqxg\nmyauM6DbaTM7N8/e3i6dro7rDsikM5iWSbvd5fyFC6ycWaGtd0nnsoS1MPNLS1y6eplsLk+z3WZz\nYwvLHrCycg7dMPn07j0Iy3zpy2/yxle/SKNe5+5nd5BDIbqdDol4gvn5BbxQCHtgEZZD6F3/ur/+\nwjUe3H2IKksMhms3RfEbJlWLkkqmaVXbpNMpev0enU6HnZ0dCmNFPGRSmSyW7dCq13n99ddRVQ3D\ntDBNB8tyCHkyjx8/od3uoKkaqWSC6y+9zG//7n9I4+SEf/2H/4Z/8A//AZ1ul2KpSCabJoTH6ckJ\nAPlsjnqtzvjYBLY9oFQs0G7WOdw7ZGFumXt3H7C0vMrezj7tepvHDx9g9vp0mi3GSmNoaoRKtU46\nnyeeyrK/fcjM7AJ7e7vUqnXa7R7NZptCMc3+7gmrKyscHh+SLeWZmJ5mamqGsbEpKpUy83PLfHzr\nQ1566SVu37rP2toTFpfnyRWK3Ht8h5PKPksLS5zsN9D7Bp/evcX+0TEtQ+fw9IiF+XmebmwxMTFO\nOpJA71t89MmnfOHNLxEJK/SaLR7fu4/V75PKJRkbH2PgORyfHvHSW7/zy1/Ab77/12+32208z+Mn\n7/6EWCTKL278nBBQr1XZ3tzmxRdfo1yus7d3yKVLV/jgw/c5LVdZOXMG1/PYPz7Gdj16poXjushh\njX7fQJJCZDMZwnI4gLb9hKYBnjcgk0ojSdBstgIyGfg3WWM4oZqmSTqdDjSooniLAjvqKCXcr8TE\nLSwpRbEEghuwYIOLSV6wpEc9vqPRKJ2O3x3H4jFicX+CEtravmk8xyIWZC7BHh8tNEDQMLSGGdpi\nKoNnARbCTKbZbAb70lEIVUC+Yl8rmJ/iNQjyVDKZDExYxIQsCkssFiORSASvSzyXYZgkk4nh4w8A\nLzi+wnJUML7F7n5U4uZLpSySyRTwLI7V33d7wf42JEvYtj9xK2GZcDiEnxTnnzejL/zj3cD2VZAJ\n1WEjIch04nviucSx8Zs6K5hcIyMGMNlsFiUcJpPJEg4rwR5bMOLFuRLFUrw/UTTFtZLJZOj1fDmi\nH5bz/DWgaUowtYtzIKRfPsIiDZEeP2wnHFaC6VnouyMRbbg28WFz0WiI4y2Y+oIVLxAfse+enp4O\nvv9Myhim29WJxxOUSiVatSYTk+MAdDttUtE4648fcf7MKrs7O+QyGY6Pj31+haoxMTmJrIQJSRKF\nfJ6joyM0TWNyeopzZ8+i6zrnz5zlww8+YHdrG73TZWd7BzkkMT87x/z8PM1Wm3a7y5tvvkU+n2dz\nawsp5Hv7O7ZBu9Wk39FJxONMTU9ycnrKv/vTf8udh4/Re32yuTyZdIaDgwOy2SxIIW5/eptEMkG5\nfMrh0SHnL55nbn6eVruFM3DY3tnh6rWrPHh4n/GJCY6PT/no45usLK/y2uc+x7nzV/jRX/2Uqy9c\n5sGje3zrt77N57/8Fb73Z3/OgzsPSMbjbD95yniphBeSODg8BDzyuTwbT54wcBxURaHZaCDLEqfH\n+6yvPSKdTpPLZGjUW0yMTdDTezTbTTrdDp9++imyLLO8vExICnH56nWUkMzB3i6tVov9/f2Ra1Kh\n0WhwenLK042nXLhwCcce0DctJFlBCoVpN+qsrz1mYmKM46MjFpcWMEyfQ3Tn7p2AGDoxMcn23gHF\n0hhPNzaonp7ieh6TE5MAPHn6hPmFeU5PyvR0k0y+wMz8Iie1MtFkgpPyCaqscHx4SCqdIRqN8uTJ\nGlNTU0yMT1OpVFlcXMToW6QSae49fEQ8lWJ7d4/Hj5/ieiHGxiaYmV9mcXGeXr+PYztMTo2zs/cE\nxxzQ6XZpt3vU6y3kIZPoG7/+dcKaxPbWJhfOn8Pq9+l1O/T0HqGwTKfV4fD4mF/96leolMvsbW8x\nViri4VIs5IjFIhh9X1F16fN/C+JEf/jdP31blmX29vZIJpK+9Gt8HCWsYBsmhWKJWDxNNJrmytXr\n1Gp1PGlAJJJkanYGLxSi2e6gmyZNvYvlevR1Ez8BSkWkgCmKT7bwc7EdMqnk8IYpB3vdbteP8xRy\nKCFhEjfGwdCQRdO0gKXbaDSAZ2lZYuJstVrk8/ngpit01+IGOKqxHpVqCQhS7LrFFCxgeVEwDMPA\nsMznYHqh8xWs4WDaG9p8AmhhJWACi+lcFGjRSAhWupguxfsSu37RQIjfG7XtFLK6RqMR7FiFe5og\n9AnpmiBHiQk/Gn3Gmh4MHEJSaDipmcF6Qkza8XickCRj2VZgtNPt6GSzOXpDyFc8drfbxR74YR6+\na1g/YIKrikKn0/a/Vv2GxTDM4XQdDvzlRZE2hi5kgvQnvMnFXnc0zEPTVFqtZlC8ANLptN8oDR9v\ntEALLoJg/wu4XJxDwXQX07dl+g2gv48eBJOu4GWEw6HAt7zT6QQEuXq9jjvwUDU/V9xHiiRs20eM\nhPNdIuETq3xehjCmUZ+b6sXrEuY8wu9AkqRgpVOr1RCpd4LEVigUAKhWq6TjKfR+j1giSr1eR5XD\nfHb7FmOFPL/y5bcon56gaipra2tcvnSFg8NDJib93IN+v8+DBw948803MW0fyZifn0eWQrRbvkHT\n4sIis7OzxOIxyuUy6WSKRrPF9PQ09x88YGdnj+OjY2ZmZ4hEI9SqFR7eu4eqKHzhC19ga2ubu5/d\noVat8dobb/Lmm1/i+PiIX7z/C1KpFJ1uh6PjExRZ4dK1K6yvrdNqt2i124yNlXAGA0zL4tyZ8wEL\nvNFoMHA8Ws0Oe3sHfPjxx7z8yuvU6m1+9/e/jWH3OTg65l/883/FJ598ytkzZ2iWK6hAq91mZ38f\n3bTIpVI4ts3e3h5vvfkGuWyGd9/5Ca+89gqnB/t02i1i8RgSIW7evOn7JjigxaMomsrK0jLT0zPP\n7IoHHkdHh7iuG3gg+HHOdfp9k8XFJRzbQg7LmKY1tGxOENaidDtdNjefMBhYWKZJp9uiVCrx6PEj\neoaJEpZptdp0Ojqtjs6//Jf/irNnz3F6egoD13eSjGqkMxl29vdIpjLsbu9RKE2xvbtPfnyMVq9H\npVb1iZDVGkbXYGZ2fkgI9a+/jc0t1teekkqmsB2De/cfMDkzhxaJs71zzEcffcbf+53/lNm5ZT76\n8A6NRpvHj9bJZHLoeocn6+u8+OJFXnzpNaqVPrduPmJ7e42wMmD13BwH2wcsLyzza1/+Kh9/8BET\nhSIThQnaPQvbdAJ+0ub2FplUnFQqjjewuXj+DHqny0/eeYdarcGXf/Mf/vIX8Fvv/+Ttge2wv7NH\nNBKFwQDbtElG42hahFBI5pNbn9Fstfj0szvYrsPS6irxZIonm1s0213iyRTdfh9FiaBGNNSwxtTU\nFJFIhH6/Ty6XIZXyHd6K+Zyv8ZZDAaRoWVYwKQufayUcRov6ftGi4IWQAv33qCuYKObiZipuvuKG\nPPq1b3ji4cO0FpqmYhh9BgOHSEQL9qFC4jVKHDIMg1QqhSuBixcUXXjmviVIQqKYyrKM5HpoiooS\n9rO8ha45kUgEWeD1ej0otKOuWZFIhFqtRjqdDnytR1EI8bziOYUxioDjBeJg2zbpdJpisUitVgts\naYEAHhYabaEb9x/zGZQsplvP88hms0hSiJ7ew7Yd+n1jCLfHA8KgmHhVVcUbuEghkRwXodfTGVgO\nSL5dbCzmP7cSVofv3290MpnMc3A20jMfdVFgBX9A+KU/s0iVUFUlkIAJVEYeEhVVRcPzGKIN/N82\neAK1eEZoDD2TD7peMFVHo/57ardbw72+hxbRgklYaMKFGY6qakNHuDT94TVnGGbQaIlrwDR9tEgK\nPXPAG01HE58B4dUg8uFFoyc+FwJZarfbyCHf09+3ogvhWg6KptDt+STJTrvDWKHA0sICA9fxY3AV\nlVw2x+O1NT7/+c/T6el0+z1+8KMf8hvf/Kav/W63GZ+cICSF2NrYpFAosLyyQrPRIJ5I0NZ1rl67\nyvraGpV6lXyhiOt6nJwcs7y8RLvdQlMjFPJ56rUa1VqdRDKFYdsk02muXLnK5994k7AkUa9WiUZ8\n4xyBUjSaTUzTYmFpnlq1MiSrnaPT6VIqjQ1tQyXe+PwXqFaqrD1exzRMQpLMnTt3ODk6oVjMc3C0\ny8HeHtOTk/zxn/wZszMlxgpFOq0W87NzPHr8CCks89qrr7G0MM/p6SmNRgPTsonG4mRzBTY2tmi2\nGrz86qvs7OxRKJZwkYjHk0xMTqMlYsSjCcqVKiFCRCN+jOnh0WFg/uKrDgwikSj2cNLO5fNsbj71\nLaxDMrbjsrCywvTMDPv7B/R7bc6srnD+/BmKuSzTM7M0Gk08SaJYyGJZFq+88iprj9Yo5ApcuniR\nZCLOuXMXONjf5/T0hKXVFTrdLvVGk8X5Jb77/R+yubONFotw7fp1tna2mZlZQA1HuPfwEWfOnkEJ\nh7j/4A63b3/KpUtX+Oijm6RSaSJxjWa7R73V5vikwm9+67d4/Gid8bEp8vk89XqD+/cecO/OHdbW\nHvPWl97AHXgkkhFq9S4//8UtcrkJzp9bJV9KUqsdcmb5AqlYmp+99z6rq6v863/5L7h65Rrf/cFf\n8fP3b1CanOL9D25QKhX57d/6Fko4hKrIfPTxR3z8yU2Mvs1ppcq3/pP/8pe/gL/3l3/x9vbGNmOl\nCd9Kr90lpmmYhslpuUq5XGH13CpSCHpmj+WVZWQlykmlTDisoAxJO3rHt/BUw2Hi8TjdbofBwCGe\niBCPxxhYFnJIQpJA0yIYhm+oIRK7/LxsIyhSkUiEiKbR13toioqqPMtdFhOWKBRiQhY3XjGdjTq0\niZ25P+F2A3hdwObicWzbCVyvBCwrNM8hJUxYVYLCPmrpCQTTvqqqxLQIpmEQGT6HMM0QuuzJSR+q\nErtr8b3RiXwUEhVwqZg4gYDlLuxjxZQsJmsB7wtilmCQCx/tVqsVRFrGYjHa7XYwgfuF2ESWVXo9\ng1qtQTKZxnXBNG10vU+77VvoCg9wn4ynByxtYVQT2MEOw2YGjgMeAUlNRLnatl90BWu+0+kEx1U0\nUn3dZyinUykGtoNj28QiUTRVxXUGSB5EtYivkfc80qkkEj5PoN/rDZtHmUQ8GbxGOaQgSTLhsMpg\n4KGEVbrdHt1uj3BYxeib9PQ+Y2MTyLJCv2eg6/2guREFctT+NJvNAs/02plMxneT6xm+PHE4pYvz\n63lSwBQXDa0fBGMMyWsEWu5RR7XR67RcLj+HWAkEZ9RfXo1EMW0LQhLOYDA0zvFdwUoT4ziDAXge\nuzvbzM7OcObsGVqtNu1OB9OyGJ+YQJJDqLEo60+f8Otf+xqTU1OBGsB1Xebm57h3/z4H+/u89uqr\nPF5b4/yFC0ihEDc/ucX5CxfI5bJ4nks0FkPVVC5fuUyzWSeRiDM+PkE0luD6Sy9ydHKCovpSz4EH\nht6n024xNV5iYrzE1uZTxsdKXLt6hZdefJFKtYrkely8cA7Pdclmsmxvbfl787BCIZNBliCZSPLJ\nzU9Qwyrzc/MkIjEunT9DT2/w03feZX9/n2Q8zuULi1y7eo5+T6er62QL4ySzWV548RqNRo2JyQn6\nhsGdu3dxHA+kMJlMgT/54z/l177+a0iyQr3ZIl8Y4+r169z+9A5uCBKJDC+9/Aqdtk42kyGETzjN\nZFIYlsHE+DR9y+LM2bPoPQPbGeC6fpN369NPiCcTRKIx5peWqdUb+FJgi6mJEnLIQ1Fkxkoltnd3\nuXzlGtFIlPAwW/zo8JhUPMnF8xdZf7xGr9tFDoeRQxKWZdPpdpiZnefMufO4DlSaFc6dP4Pe6VCv\nVnn1pVfZ3t7DsAfcf7jOW2++immbaIpGvd4kGo2gKGEymRzlep/tvQNmZmbIZhJsbq6RSKggWZw9\nO8/4RI7t7W0+/7mXicXCpJNxFCXM9laZuw8ecXx6hGH1ePjwPv/0n/4TfvzOj3HlCD9596d8eOsW\nIU0lk8uSyefRXYflM+c5e+Eclm1imn1yuTTtRoNsOsXe/gFqNMrY+CTF8Qle+8q3f/kL+Hf+5A/f\nXlxcBGBsbAxd7xGWZTLpDLphURgrsru/x9TsNOOTExCS2T84IZ5KYFo23a4+tNT0d2JRLYJp+w47\n6XTKj/Lr60NCka9HFvCuqqpBprH4I4qOKGZi16iqKvV6PZiKBEFN3NAEWWlUMws856ftm6z40HYi\nkcDDRQpJmJYJHkE3r+u954q/aZpYAyeYAkcDPJ4x26PBTXIwGDAYMppFQRWe3QJuFuxwMfEJM49n\n+95nU/joX4FaiNjMUXvRgBk93Fn7vvZm0KSIYyeSrkSilrAgFTwF0UQNBm4AFwsGvNCmi9ADX+9t\nkBpmDYtjMGr3KXbSInUrlcr4LNhIFNM0sG2HbDY3VA5EhyEsz3LIhVGJaOxCoRCVSgVVVUmn0895\nqYtjLvb4tmM/hzCIY9XtdLHtAfV6I4iUHZ18n03Kz/zthVpArCYYhnWEw2EGrkNIDhGJ+BIcwzSC\n9Ya4XrvdLolEcsj3SNDt6oA0DFhxg6INBGuLaNS/Nnr9XnDt6bpOPp8P7HOFy9v4+PiQlGcGfgjC\nsa1nGIRkedg8uENr2QTZbIaBZaNENeyBQ6fbJRaNIrkSut7mwf37RKIRKrUq01NTxIarEXsw4MWX\nXiSRSLC5seGvfVSFRCLB/bv3GBsbY2piklAoxOHhIZqmsXt4QCQWZWJ8nHLllE67zcLCPIoSxtB1\nIqpGLpvlxgcfMjM3Q7fX5933fsrqyjLZbJ6Pbn5CXFF4svaYvd0ddL2LEg4xcAd0Om0ODvbpGyZG\nv0etVqHdbhOLRKnV6ywvLxPRokxPTXJ0eICud4lqEd577z1mZ2Y52Nslm0mSSMaoluvMTM4wNTmG\nbfZJJ6Pcvn2bdLbA3OISa+tPyGaSKLLMabWCHFZ45ZXXmF9YYnNrm1JpnHPnLyIpMpbjMvAkNje3\nePGVV8gXCsjhMKlMloP9A1544SrdZhPXczAtA0kOkUgkePzkaXAfUBUtkGp2Ol2WluaZHCuh93t+\nUzU2RrV6yuxUCU2W6fe6JJMx9nYPWX+ygWmYuJ7H0cEu3bZOtVLj6dNNut0uv3j/Bka/TyqZIhyW\n2dnZ4fannzE5O8Px0bH/OYuE6fV7HB8ckk6lmZ6aZuBBOpfjwpWLxFSwLJu5+WWf7a0oZLJZnIFD\nMpOl3W2ztDjPq6++xOH+HomYxgsvXOfmzV+Qz2X5/vd+wIcfvM+rL1/nwf0HfPzRLebmzlBr1PnK\n177C3Xv3WF1d5bR8wMLiHK6SJZJIMbd0huNaCzWR5e7jp/w3f/AH5HMZ7t27QyIW5dL5c8SjEbY2\nNlh/vMYbb72FqkZYHkbnXnn9a7/8Bfy7//ufvP3iSy+RTqXZ3d+j3e2ytb1DIpnA9vzIuVQmh6JG\nKdfqRGMJGq1mQBrzC0eIcFhGCst+dz4kVFmWhRpW0PUekUgUkbYVBJCMWHAKxvKoT7gsyxQKhcDi\nUkyHolgKiFAwzoUuV8C2Yh/oOO5QM+nQ6/mTy8D1C6zYr8ZiURzHL/qex7Cg+h7iyKFgxwgEk7co\ndmIiGtWIewM3gFfFtCX2lkJ6JibjUfa8eCzB/O4M9YxiXytgXLHvHHUgE8dMkPtG98GFQiEo6KLx\nKBaLweOIfZuQrdm2TbfbJZvNBlnUIjVMKAEsyw6g83q9HlwTosiONiHCNtSH9m1UVQlY4qqqUqlU\ngvcoipIgZoljI8xjxGSeyWQCbbXYYYvCJ7zafaMLG3CH8sEu8ZjvECjkemLtIv4/igKJ4i8KYiAh\n1DRAGmrUn3EFxGpCNJWhUIhEIgb4BK1oNIai+EQ3QR4EqNVqgSxMENSi0SjVaoVsNotpGkEDISxl\nhcWqSHUTELo4P+K4AGRzOUzTChozEa6iaRFs08TDT8OTgIFlIyNxfLjPubNnWF1dYWDZ6N0uN372\nc5KJBNaQjLf2+DEnh0doqsrs7CzFQoHKySlzMzMU8nmatTpm38A0DHLFAq7rcuP991lcXCKZSvvG\nJLE4BwcHgVHN5IRvNNTqtrh27SqxaJR0OkUkFmG8UERRwnie6zfbff/znMpmqDcbZDJp8AZksxn/\nmk8liUajPrs/EqXbafCDv/wLxgoFFpYW6ff7LK8sMzUxzuq5s1QqVXb2DikUC1y8eB5d77G5sUUm\nm0dVIyhhjWKpwKULF5mZmyEsy5w5exY5FKbRaDI5OcXM7Azlcplmu0YqlWR5YYFms8HSwgKl8RKS\nBDNzs+jdJo5t0GnXePDgHteuXuPw6Ig79x6gKSF6eod6ucrM1CSSB72uTjIeQ5Fl9vd2wXNxBi6q\nIlM+2UeVPXLZDD29w/0H9wkpGmtrT+j1eiwuLPBk/RGeCxsbm4DE5MQUf/RH/4ZcLoOLx+zsLDMz\nM1SqVSZnppmYnGBnb5t8Jsetm5/wj/7xP6ZQLFKuVBgfK3J8ss/M5BhTU2M0Gx1u/PwWjx5vcHJy\nQCaXoTQxQTyhYdk2zWaVpfl5NEXlhesv4TgeruNSbzQ4Oarx4gvX2dhYY2p6lkcPntDpNFldWSaX\nL1CpNkhGVJYWZ4jFNFQ5SbvdolQo8lc/fpfv/eindHo9fvi975OMhtne3ODpo4ek4nHOrqyysbGB\nh0Sno1MaG6dQKGLaFitXvvj/qoBLYlr5//LP//I//DPvk1sfkUkmCCt+3JwWi9JuN7EIkU5lcJEw\n7UEgY5KGkB08m5jTufTwhqDQ7fYCKDsSiTCw/BxiyfOLlTfMZRZ64lGSmYCNRRER8K5oFsTN2Wfo\nRp6T9DxnKTpkdIvJTUh3wMUd5t1mMs/IPobhw5s+XD5gbGxiKAfrYQ+hUtfzcEYIY0gS6lA+5jhO\nkGqWz+dpN5rB6xITsXg9ozv10Sam0+kwGAyYmJigVqs9J00bnQ4FyUlMfyJTevT/Yh8uSFWZTIZy\nuRwcn6Ojo+fY6OIcJJNJGo1GoAoQ5irwjDQnoFkRlrG/vx8UHEHyGn197XY7eCzTNIMAFVGUR9cc\n4l/BSPf5Dr5sz29OrAB9EEV79Gux6/XDT3SischzKwYhoWvUm9TrzYBYJ6BvIckSz6co8hBK9yfy\nbrcbNIiaphBW5OA1CEc5wVjXNI1+zyCRjAcywIzO8KAAACAASURBVLCsoKqR5xAiAaWLYyFkf/1+\nn2wuxenp6RBeVwJ4vV6vk0pl/i+fCR929xsjkSEgyzKhsO8uqOtD97mQQr1RJZFIYDabRFMJnJCv\nf9dCCvlEkn6nSafTQg5JLC0t0W210VQVQ++RyWSIp3xf/U6nQ7FY9E1ebt3mjTfewHEcygdHHBwc\n8MYbb3Baq7J9uM/09LRPPJVDFHN5TMNgdnaak8Mjrly5wt7eHrVajYFkUyoVaHXa7Owd4HkeZ8+t\nYDQMMtkUISQsy2BsvMTTzQ3iySSxWIzd/T0ss0+pkGFgO7TbLbLZLLbtkM/nWLv3gHhC48rV8/45\nVCO0Wh2OT8ocH1a48f5N1p8+5fylM7z+yuu889fv8hvf/E1+8eENZhfmeenll8kXMgwGNsdHB0zP\nzzI+Ps72xg6JVJLPHtxhfn6Os0vz2JZHo9Wi0+5TKBQIIdHtdUAO8eDhOptbj/mtb/0m77/3U9qt\nOmFZ49LVl8jkM7Rrx+TiUWzHpNHq0OkaGH2/qZTVMLlckb41YGJqis3tDeanZ+i2dSKRMLIqcffB\nfV557S2azS7379/l7LkVDg/3MfQeErD5xHdy+zu/8U0Wlhcon1Z9b/Rmk9n5eeLJBNVqFceyMXq+\nYsEeeNRqNRq1CpcvnWd+dpIf/+hHzC4uY9sykViG259+xrmLZ3j99Zf56c/eIRWPkUulqTdrpDIZ\nMpkMlUrFX7P2+vS7Jp7j0WyWSSfiKLJvvtI3PG68/zGf3bnHP/mv/ws2tz6hmBlDCSeQ9TaOZzM5\nO8O/+8536XZtStMz5MdKjE8UqVdrhIDKcZnz58+xsbHh3x+iMrMLi6ycO8vu7i6/8u3/atQk8//x\nn/9fTOD//H/6799eXVnitHyM3u9TGp+i1e6QzWVJZ/J0ezqyHMa07GAKYWTf7N8Q/WIGPpNYkKdM\n08Q2fAg3l8sRVvysauHXLPa/YlocjUwc3XWLAikMX0RQg5hYxPcFHC2g4VGSm9Brh8MyIKFpKpLk\ny5dEfrcbJI7JhMMyg4FLOCxj2pb/mLFYcPMWumNhGCMKV7ACGNqrCgaymErFxCvIZUISBATwN8Dp\n6WkAq4spLZFIBAYwYtISTHkBrwuikyA7CT94UfRHSXkCMhcseZEEJtjwYooT06RAOcRkp+t64A4n\ndPjivAsERLwfEfEqvOLFhAsETYKY1oVhiWBde56LaRqo6rMds7hOMplMkPomUAThGGcYffKFfNAs\njQag9PQekuSjOYIYKc6FKIQ+18E3+hE/k0qlcF13SF70kEMyHl7QjAkyZjyWQNe7ZNIZej09kO/l\nc3kkKRQU1tG1idhlC+MVobfP5rIA2LaDJIVwHN/kRqyNRiWLgh+RzWafa247w2lbln2VQ0/vk0wl\n/PetabS6bULhMOFQGFPvY/T7VKunXLl6mXQySTaZYvPJUy5cuohhmuQKea5euszewT737t0jm836\nf3M5imMlIrEoYUkmGovxiw8+IFcsMD45SaPR8BuhToezZ8/6qJPjkM1mg+t1d3ebF1++jqapRGMa\nIQkGjk1I8mg3uhSKeV9j79h0e13+6I/+kLGJMeYX5tjd2ebM8hLu8Jhcu3aN5eWVIVIjU8hmePz4\nAa7rUKmccuPGDcZKJU7LVW68/wETE5N87vOvYzkW3XaXL77xReqNOpcvX2b96TqpTIpsPos7cFAj\nKo1mg6nJGRr1Fqcnx0xNTTA/O83de/dxPdDUKAPg5OgQx7Z9drjeZWDJfjiL45FLZ0nEY9gDh5de\nepn9gx2unD/P7Zsf47kDSqUCHb2HM3BoNJtEZYVapY7twpPtLVYvnOfW3btUGnUuXbxMpVYnnc2S\nTBVJp7PEEwka9QaNWo3J8UnOrpzh3p27vPrKa0ghiUatQTaTQlZk+n2ddCrJ9MwUhUKO9fXH4MLs\n7CyJeIxELEGxWCCZSGL0ehhGH9vzWD57jkarySufe416s4Zh9dje3eTC2TM++W9ujkajQX/4GYxH\no7ieRaVSRpXDxGIa/X4Hd+i+mU6kMA2D0lieQi7N0/X7pBNpTo+PKXdMDqpNppdXGZ+e48bHN+ma\nPZSoQjydwnIGrJw5w9LqMvFkEllVUKMaC/OLTM7MomlRZqZniRfmf/kh9O/96f/6djIV57RSRY1E\niaczLK+u0tX7PH78mHhimDOsqM+Yv5oyNK9whzGB4SDMfjAYkE4kiagamqIGN1zhDCZYvWKf7Ef/\nGYE3eK1WCxjFuVwuKHpCMiM06/4E5EPMgiAkmM+CACYIVAJW9n/GJR6PIYdkHGfAYMhAtszR4BBv\nOEX6eyd7ZJ8tyG6hUIhGo0E2lcYbuDTrDeRQiHgyMYyyJLAbFQUhmNzxCSvCBzsSiQQ51mJSFJO2\nIIT1ej16vR7pdJpOpxNMqI1GIwjIECQ1v3j5qWjCoW5jYwMgKD6jREAhDxPyPHEcG41GUEjEdCjQ\nEF3XA46CQAhE2Ia4DgJpDPgZ40MIfVRj/TetPTVNo9frIsshPM9FkghY3YoSHnrWO0Fj0Wq1gvMr\nXott20ONfArXe6YlFw2n38wlg529SLUT100oBLZtBfC4yDwXKIhYTYSH+fOu6yF22YqiEhpq2l3P\nxegbIBEEjPT7Bp7nT96pVCrQlVuWFTR0nueRTqdpNpvYtoVlWti2QzzmB/oMnAGpZIpIRAuOpWhc\nRfNqmiYDx8VzfdZ/OOT75ktISB6+/n7YxHVaLdLpjP8+Bq4fTan7CW0XLp0nnUjwyc8/YHlxiZAS\nZv3JE0rFIscHh/45U1WWlpfp9/vU63Xu379PpVLh5PSEuYV5FM3nrxTHSty8eRNtiKBMT01RyOZ4\n9913WFhYoNls0mq1fF9y06RSrRCLxpkYn2B8bJxSsUS71WZ8ahIPj0giSiKRJJ6Ms7e9QzFfoFYt\nk4hHWV1eodVsooQVlLBCpVrl+PgYq9/n1379K6RSCXo9nXQ6w9LSIqqiks+XcF2JaCLB2bNnMHoG\n9+89IF/MMjs3w/HJMZlsmla7iTMYUClX2Xj6hJmpOdrtLjtb27xw6SLtZp3tozKpVAbLsalWKzx6\neJ/Z2RlkOUQsGkfVEnQ6Ter1Bu7AIxqN0W51qdSbTM3PcbCxyae3bqHIITQtSiQWYXJyksOTQ3q6\nT4TcO6kwNjVJvlQkXygyv7jI0f4+iUScaDxBoTBOPJ4gFJJodxoUigWKhQLbu3sUS2OUxseYmZ/j\n6OSYzacbnFk5Q7PRxHFcHNuifHpKMpVifmbKd/HTomgRDSWsUK1WiEWjzM8t4mDTbvtk5F63xeL8\nHJXyMflsmolCntOjE1ZXVmm327TbbXq6juRBIhFjb3ubpflFbNPkk9ufsr17wN7BEfVmG9M02Nvf\nI56M8vFHN7Fsj6OTCnfWj5iYX2Jm4QyJTIlwOEIkGkVTI+RzGQqFIpZtUy5XUSMRzp8/SzQWI5PJ\nEIvHicZidHs6ucnVX/4C/uDmz9/u6l3mlxeRtRi2G+LR2hNs2/adeoYkINPyd17xqEZumIYlpmB/\neh0QS/hT9cD293GZTAZJkmi1WsGeVRRtYawiIG4xhYvJWdzgBWtaENtGHbMEg13szsT0KXbkoviI\nxxA3cc+DcrlCKpUewupScNPzJyFwPBc1omGZJolhoIgvicv5eb7DwhoeGseIdYCIQRWFS9z0xdeC\nNCaQATFlCqkTEJDdRh28xHsTPyeY3aFQKIiyFNOhKMLJZPK5vXgmkwmMbsrlMoqiBMcbfEMXEVzS\n7/eDgjo6dYt98djYmA/xZrOBE52A7YVhi5gGxbkQKISIURTIwCj0rKrhZ2larkNYCWPZFoOBg6L6\n8LNIoRvdk4uJXDQT/jXgYjt2EIcqwkP866WPNyQuiuOYzWYZDOzhesQjFo9hWfaQl9BlNBPeL5Sx\noSmRG5x/cTxF4p2E5L/2oa99v28wGLhBwRUNXKfTCaJIBSztE+8SQ/i3MAzzSRCNxnDdAe1WO2hQ\nxHFOJpOEZYVoJBp8VoRXuk+cfMYZMQ0DvdulUCyyv7+HHAqRiCUZ2ANOjo84PD7wNd5f+DxxKUyh\nkOeTO59y7tJFtjY2YOAyNT3N1NQU60+ekMlkmJ+fp28YnL9wAUIhFhYX0Hs9VE0jGo366WW/+hXm\nZmfZ293l7t27mKbBysoKT548odVqsb21z87OHvlsic2nWyRiKfZ2Drjz6V0WFxfodLsMvAHReJxG\nu8mZ1VVymQzddotq+QTL9OWd6+vrSJLE4eExtWqdsBLmS2+8iWWZlE/L5LI5kslEgDBNT8/yyc1b\nNNsddrZ3CckyU1MT2KbB9s4Wnjvg5PTEP6fOgGKxyPzsLO2ODl6Ih/fvMlnMIeGhZUpEI1FfAuZY\nnD17BlWReLL+hNJYiVa7w+zcJBIytg2aqpJMF2m0Tb7zve+zsrjAw4cPGRubIpPO0Gy00PsG9+7f\nY/XCBR4/ecru/hGKonDu7Bk0WUF2PaKxMIbTxzB7FIp5Op0mJ8d7LC3OceHiZXpGn0gsihpRqdSr\nvPzqK3R7PTYeP2FlZZXx8QnMvoEiq5wcnhBJxDnY28bs66QTSRzLotqoEgpJPF1/QrVS4fy5MzQq\nVVzLIpWMMzAMwnhooTB7ezv47bdLvlDk3t27RLQIe9s7JJNpzJ7FgzsP+dKbv8KjtQ2++/0fsbh8\nlp/94iP+g7/7bfYODxmbmKLa0OkaDs1OD1SL3/v93+HoeBfH6vPitat0W02WF+dJxWPYhkH5+ARZ\nkpibmeHOrdu06nUaDT/8JRqPs7OzzfzZl375C/iNd77/diweJ5bOsHd4RLYwjmn0SaaTATErGo2C\n56IqYXK5HIZhBBpooa+NRCIMHMeX6wzZyqMWpcLU5Bk0KQekI6GPVRSFer3+XKqV2KWKnxXQs8hT\nFnIoAaULeFg8xyizd9QNS7CSu11/ReB5PnktpCjYA4dIRPWNQIY31mfmHOFg2tOGMX6iSRCTqtDo\nCmhbFBRBaBPHVMC14lgIo49isRgU0NEiLiBT8Kf7v7kHr1arAYlPrChEctaobEw4uAlGtghMGZ2E\nRdMhCpYokvF4nImJiQCmFkVTrAFE0Rd7YdFsiKlesLjF+RbmPc+ec0hcM/uBasBxbGKxKJIEzWYn\neD+jx3XUcCcS8dPY2u0WuXxueJ67QfPjW8c2Agjdsix6vR7dbhfwUNTwcA9vIoVChKTQcIcfDpqN\neDzum4h0Opim5as3wgqGYQ6LvovrDpAkP4xFOOWpijr02neCxDbhAicQEdEgpNNpgOf07eK8+BG3\nAwqFfNDYimvNh9hdQqEwvV6fTqdLv29wdHQcwPa1Wi3wdz8un2JbNtm0H98bi8a4e+8+nXabt956\nk/rJCbNF3/wkVyzQ7LTJZ3MkY3GSqSQ3btwgV8hTqVT44z/+YzLZLFevXuUvfvCX7O/tsbS05Lt8\nDc1f8tkcsUiU05MT5ufmmZgcZ2xsjNu3b2NZFtevv8ijh4/QVI39vQNmZmeZmprEcWyy+QLHJ8cQ\nktnd3cFxbHZ3tkknk2xuPOUf/ef/GcfHx7i2g4tHKpXh6OiIRDzFN3/jN/jv/uC/5eGDx2QyWbq6\nTi6XZ3NzE8dxuHfvPh9++DGWA+tP132ynmny8N4dJM9DVSM4ls301BTnz57jRz/4AWuP1vjss7vs\nHxxw/epVHMukq+sUZ+ZIDfklfaNHv6/jOg65XJaQLHNwdEpIhp+88x5//ZN3abVbZLNjdPoG6xsb\nXL1ylacbmywsrfKzn92gXK7S7nQ4ODxman6WldWzTIxPc3CwhxpWuHrpEmsPHxJP+jp6vdMlEYsR\nj0Tp9TokEwmOjk99PzPPIxaL4HkuY6UihXyOUr5ArpCn0+2QTCbo6zrJdJJWT+fJ+iMWZ+fZ2tjA\nMvscHR1RrVXx3AF6t8v4WAmj3yOTTtJq1LEtg/HxMQ729zg+OWJ2ZpZ6rc7e3g5f+NwXMPp9XGfA\nzZu3mJ2eQwkrPHjwCNeT+NZvfZuQHObMxYtcuHieixfP+xbNLYOLl6/iAa+/eo3Np+u0mw3SyST9\nTptep4VlW8iey4N79xgMBmxvbZHLZqhVTtnd2WRlZYnyaZX9/QOikQjz51/+5S/g9259+LYXCnFa\nqWE6A6q1JqoSxnUHmMN9Jfis7HQ6HehPxU1dwL1iIrIsi/Hx8eeeQ0DFwlJyVCcs9n6WZdFsNkkm\nk5RKpWBvLIxSxI5UTLDCEEU0AGKSE8VQTK2j8hxRCMWet91uBzrqIEta9m+CAuoEAuIWPB9a4g0n\nMiHTGpX1iGInitfftNMUzYyYxkXTIgqKQA1E0e92u4EBjIBdxTEXMihheiKKqSigAp4VcrdR3bIx\nTAjr9XpBEyRIVAJmF5O6KNr9fj+Aw8TvdjqdYF0gXkOj0XhOIif2wGKNADzXAPrXiH896Xp3eN71\nYMr2i100OH7iPbbbbbLZbDDxi0SzRCIeuMuJ8wIMCWBpIsMptdVqMTk5iab5BMNnzHUPVdVQNRXH\nEcX42WpD13VKpdJzJEOx7vEndse/hiQCjb2vk+c5yF80a+J6AL8prNVqRCIR34v/b6wrbNum1Wqy\ns7tDv98Pzl+/38e2bDQt+sxEx/OoVqvMzs76qV7DhDCB6DjugNWVFSKahtk3gsf//Odep5TP8vEH\nH1DI5dB7OgfHR9RrNR49esTU+ASP19a4dOkSIdk3Q/nk1i0Mw+Do6AhJDrG7s8Mnt26RzWaD5tAy\nTNwhsdA0TeqNWoDiFAoFDo/2yOayGKbJ9vYWqVQMOQwHB7tUqnX6hsH+wSEnJycIm1wkj2ajyeNH\nD1DVCA8ePcIw/Ou10+3x9W98g5/85K852t/n3LlzzM7OUSqWiEQi1OtVrl67wvr6EzQthuVCKpXm\n0sUL3Lv7Gd/42q+h6zoXzp+jWCgyNTGJbZrsbG2xunqGbrfruxPGIrz51pf4+Y1f8MW33iIej9Nq\ntWi1mywuzpMaojQhQmRyE8iyn5O9tbFJNKrxe3//P6LeaPHoyUN2dw+5eOUycjiM60p+xPPkJA4O\n44UimWSGyYkZLl2+AngYpkGj0UBTNeq1BkcHZWxzgN7qEvJkLMOiVamxuf6EyWKRdqOJY5g0KzWs\nnj+xDzwH3eiiKDLxWIRK5ZTHG2v/Z3vn+SPJnd73T8Wu6twzPdM9PTt5dndmNi93yTsmkbpA8c4y\nJMDyWQJsWbANyy8M6E/gKwECDL9wBGwLBu4MwbAVfJJIne4YjuHI5R1phs1pcugw0zlWdVX5RfWv\nduh3gl/YY9QHWPANseidrqknfZ/vw6ULF2nXW3RbHT784APmlxfIjGWwHZu1lTX2yiV0Q0dWVbp9\n39sjkUyytb3F4vw8Dx8+wvM87t2/R6nk31M42N+n3qgRj5nouoKuqfy7f/9vMKI6X3/2ayiyy4fv\n/5REPEp+YpxmvcGPXn+DSqVCJjXOG6//NUPL5Xd++7d59PAeZ04vY9k2nVaTTq/L7Owc6+vr7Ozs\ncP7CKuCSHc+zu3tAPj+DqkaYXb168gP463/+Z6/1BjZH1RqW7dBu+epwVZbIZrOMjY0F1cPxe9Ai\nmIgqWRy3OG6OIlquQmEtBE7i5Stmj0LIJl7SiqJ85YUsXvjCg1pUpSKJOK66Pr5/LGbV4qV3/Eyo\nuNN8fFYrqUowQxXKaBHMxD61uM/tui7IEvaoYhKrUuLQCTw5Oyn+KwLz8f1iIb4TbfTBYBDMx4Xl\naSQSYXx8nHa7HbTKhRJb/JyPC6/EapZIqI5XwJ1O5ysGK+JzCJGamIOLqk78/IX6WvyMhbZBrEz5\nAkH1K8mB8GkXnQDRaRFV83E9wZPvbdS2V5VRgqgEM2ZFUVEULfj+wa9O0+n0qD3dC4K0P2P23f9k\nWWZ7eztINv1NgEhg2Sq0CtGoOVoFs+n1uqNrap1jAkeV119/g1QqFWgLBoMB9Xo96JaI7QHwrVJN\nw6TT7QSJ5tAeUhttKAjHNPG8iWdf+FWLZ1HY0h7fOPB33qPkcpNIkkShUCAWMxEWxpGIb/KSyWTQ\nNP+WuUhsY7FYYPu6u7tLdKT+7bTb2JZNKpOmMDXFJz//mPLBPr/z2/+AH/3Vj4Lv9WB/n2tPXyeZ\nTmGONkFKlTLD4ZB8LsdLL73E9PQ027s7KLJMoVAIfu+KxSLThQKddof33nuPZrPJ8ull0mlfUb+/\nv08uN4miqDz77HNIHtj2gP6gy/z8PItLZ3Fcl1KxxC+/9DLNRgM9orNyZoXpmWkce8j4+AQPHz5i\nZmaWbHaCjz76iJ2dHS5cOE/cNFhZWSEeT7Czs0un0+LTT38BOCwuLvHxjV+wev4yOzs73L93j/Pn\n1lA1hVqjjhGN0mzUiUZjPHr0yDcBklRS6STRqM5gOESLxjHjCcyoNhrfxOm2OzjWANP0xa7ayE71\n9JlFpgsFFGReeeUbfPnFTUrlKpcvXWZz4zGnTy/TbLf5+Oc3WFpaZKIwyV5xj7HkGFevPs3/+Is3\n2Nvf59KVKxRLRW7fvsXNm7eYnjrFO++8hzd0KRSm8Tz45Oef4rkuuXyOZDLFg/v3qZTLNOsNigcH\nyBGVO/fuMj03y63btykWy6TSGertNjIGf/gf/pCl+SUcZ0i31+fFl17k9s2btJu+TbJtD1lbOweO\nh+v6ydnY2Bh4UCwWaTab5HJTbO/tMjszQ6fdZvnMEpWjCrmJLBtb68xMT7Ox/pi9vW3+8T/5R7Tq\nNRKxOLVqldXVM8RjcWQkpguT/Orf+g7PPfc0vV6Dg/0NdFWiXjtE1wxWzq4RNaPYA5tvfOOX2drc\noFavMrRd+sMhj9c3uX37Lr/8q/8fGLn8xQ//7LVGs4GqapjRKGOpDP1eh2w2+5X5snhhila2CBpC\nOS0MNUT2Ll7QIoAJ/2rRfhQzaxFENE3j6OiIfD4fVHGiwhdta1F5CiWzmPWKQCBEZmL2J1raon0v\nApKYO3qefx8c/EDaHwWtILg6DtYoKAuHK/GyDQRbnq8OFwK/SqUSVLnipS6Sjm63S71eDyp4EbTE\n5xPBVszwxR8R+ERlL66kiVnw8UtrogoWnYd+vx8E0kwmEwQKoXyORCJBgiIqyFarFexXC/2B6IQI\nYeFx1b9IKo6bxYgALz6/qFBFZ0RUmyKpEp9XUeTRimEsWLET7WT/e9aCXXXRvRHdjP+965FIxH1B\n1DGBmkjuGo0mkiSzs7ODZVl0Oh22tjY5PDzk5s2bjI2PUS77QakyuvXseR6rq2vBPnan0+Hg4OBY\nUqCPZvvmqLvkB/7YSBvi+xSkRrvgfoKTzWaD7Yp0Oh0kqeJnLrYnhkOLVCpJJOL/PJLJ+CiJkEa7\n49bo32ljjjwXRDteVPBihz4WiwWJKICqa8gelIsllNGYrNlo8OmNGzz7zNPMnJqm1+36++i9Pmtr\naziOw7vvvcfB/r5vslSvBYdF8vk8U1NTPHzwgFOnTnHp4kWq1apv7lIocPfOHTpt3+vgylNXuXfv\nLvfv3yefz1MqlVhZWcUZwhef3SYajfndEtMERcVDIaIbmKZBvV4jk0mTSifJTU7SbncC/Y2iKGxu\nb7FydoUXX3zR77qkYtz+8nN0PcLe3h4bGxsYpg64tBp1dnb3kWUN3UzgDF0uXjiPEVGp1qtIkkIs\nGiUaTTC0bZLJJOVymceP15Ell1whz8q5Vd74ydt869XvMOyP1vckhX6/T71WZW9vh0QsTrlSIp1K\n8PjRPRrVGqZh4jouf/Rf/hs/+P6f8U//2e8yO5vn4sWL2MMB6WSK2YVZonGDpTNL5KdmiBhRdnfL\nSLLMT997F0XyUCSFK1cv0Wg22drcRJVl3nnnbSYnJ4joBnfv32XgDClVyvQtC90wOSgWWTt/nlLp\niKvXn0GNGGxt7fLmT96idtSkZw352tee56c/eRvZdXn6+jNIqsTAtmnWm74TYsTg9OISnuNy785d\nYmaMsXSa9999j8LMKW5+eZOZ2Xm6A//ZqR4eYUQMVCNKIhZnYA1YXTnH0VGN69eukYzFaTebyIpG\nPJ5gb28PT4J0MsMLL7xEJhWl227TajZo1at0GlWq5SqaFOH9Dz4kqht4Q5edrW2ihsH+3h4PHz0g\nV5hkYNuUDis8Xn/M3/n7v3vyA/hfvv7D15BlHA+iMb+K0iIaiqrSa7eYnMjiDF1URcE0DIa2DZ6H\nrChBi/erJxIjwYxTBCKxAyyqNV/Q00LTVKJRE0VRA0GapinoujZatekiy1IgwjqudPbbx25gDuMf\nxJCC4CG8oUWbXrQmRdUK+PNvSca2bIaOgyxJo/m3EVSZ0dHcWxwYETu2kiTR6/dRRknCYDBA0TUS\no7mXCDKinSzLMslk0q9SNZXeoI8i+UmI57j0ByMvccNE03WGnosRiZCMJ/zKaGgH3YZmp+3fSlcU\n//MPbSKaDhJfsS4Vxi/u0HckO57oiGpKdEGEwC+bHcN1HXqdHnEzzsDuoWkq9sDGNAxkxVffe7JH\n1IgG+gJVlanXayOP73Yw2wWCgx3ieRGtfz/g++1mSYJYLM7QsQIf9uPiPzGzbzbbDIdDdnZ2Apcx\nMVZoNpv0+/2RSM7fP+92O5TL5WDDoVgscnRYpdvtB8mG0B0YhommqeTzecbHx0gkEqTTaZaXl4nF\n/IAZjfrB0TdlMcnnJ1FVhXQ6NRK0+UdYwBe+qZrfeREdCl3XGDo2nufrOroDX0gm/O51VcPDF2h2\nOh0KhcJIJ+AFs3N/HKGOVub6o99kiUTCf77wwDSjQfLtC+w0dF3DdYccHlYoFkvous7k5CSVYhVZ\ndomnUiiygqlo6Eacjc0NXnn5OuXSEWeXz/LO2+9g2b6mIpmIE49GsQYDXnzhl9jc2kaP+Il89eiI\nVDIdVJzlSoW5uTmG1pDh0CE7No7jDFlcXOTjGzfY2t7h2rWnfF2AaVCsHCKrMnt720iSRzRukkjE\n2X78mO39IkYkgqponJqbw7aGXFg5x87e0Op/IgAAE1xJREFUHkYyxvbjxxw2aqycXSU3VWCvVGJ3\nY5MrF8+jGzpzhQLdwYC9vX1eev5FZBT2DvaZX1oglUyxMDvPJ1/e4puvvMLB/gHddgdV9lvq8/OL\n3H3wkPHJPI6k8oM/+q9cf+YS3/zWt5k5NYftyswuL5HNZXEHPTxJozfo+aNICYoHJeKJBPv7RQxT\no1Fvceb0KpGIwebmNpGISiql8/oP/4R+t8mVCxcYH8uSO5XHiMcYG5/g/LkLYA358L0bSK7C/c11\ndFfixqefcvnSJTwgl8tjux6LZ1bYK5Vp9SzaAws1orG5vcfW9gGbO/u88p1f5Yev/5ip6QXaPQsP\nlQf315k5tcCVq9eoN9v86Edvc7i9yy+9+ALpVAJZhYihkkymiCUTJDNjyLJELJ7wZ/1Wl6npKba2\ntjg8rHLt6WvoqsGF8+epHVXZ2dlhZmaGaDJOv9Pj8uVLHBxsY5gKuiYzNztDs1Hnr3/yY955+22m\n8zkqlQrvvvsuVn+A1e/zi08+5mfvf8D87CyxiMzezkPmZmZ4/4MPONgtMjWV5+ioimUN8FyXvb0D\nsmM5JN2g222THUtx5eoFzl//5skP4H/+p3/82tAeIksSyUSSdCaJpimAhxGPUqkegSLhSR6dXgdX\n8pBUGU3RgpmqqOiOr0npuh5Ybh53K7Msi0ajgab5bWRFlbGsPqZh0Ot1A9ekXq9PNOori8WsVVZ8\nYxXXHWLbA1xviK5rOI6NYZjB5xGBShiHiOpHzNBFm9XBQ9FUUGSQJZRR0iEqdXu0YiX2oYWYThgR\nAHijij8ajaJHIjRH62AikIqKEwi6EoNeHzNiBP/PwLL8K2aOvz/fHfhdjU6r7Z/Jk2VcxwEJLGcY\nqMRdx8F1HDw8XM/DcobEEnEkRabT76EbBo7noRsRFEkOKu7jIw6AWMxE1zUePLxHv9+h0ahhWxaW\n1SceTfi7/a5DuXqIbmhoqsLQttB1lV6/i6xIiEtikvTEPEdU7SJ5E9+F3+727XVFN6Xf71OplOl1\ne1Qqh1SPqnQ7XQZ9eyTG6tNudQLzmUgkwtTU1GgDIIppGqTSCcyowcTEOPFRwLUsm1Qqja7pxOMJ\n0ukMiUTK92YedSSOdyMSiSSyrNDtdFBkBVWNsLe7j6pqKIo6OpP7xO6302mjqDK2bYHnjWb4Mv3B\nk7m0aZrU637bPDB00RSarQYRXcM0DBKJuJ8A4AVJqF+B+yt1ruvguDaWPUCSPEzTYGANgmfNcRz6\n/f5I7ObbAQt3Q9/+No7j2LQ7LVzXYXJiwvc4GPSJZ2J0By00I4JuRGg32/zBv/iXpDPjFHITKBEN\nOaIyd3qRvm2xXy5xf+MRE4U8CTNOs9Wibw9QIyoHxRLJTIZsLk/H8d2vPv3wY7713Iusrz9gv7LH\nR5//HAmFK09d5u6De1y+dDEYf5gRg4imsbW5wVh6jIWlRdYunWf29DIHRxXqrSbWoI/rOURNky8/\n/wLPtinuHmBZFocHh0xMTHBYqRCLRdkrblPIZen2WxzsHzAxkeHx5mOmC1McVYrEYjrTMwWwPe7e\nvkOv2+Ho6IhPP/k5l86tUtzdZmZ6hqFjs3+wx6u/8g26VhePIc+/8HVe+OarfPHlbYaOwzs/fZte\np0csYjA7lUfRFfqdNtagz8rKWd9q1zSRFZnMZI7CzAz7pT22Nh+iay7XrpzHjCgszBR46up10uk0\nt778EsM0kB2XQbvFuz/+se+LYFvMLizx4OEDEvEo3/3uq7z19k947rlnmZ2dxbVtrF4X0zDIToyz\nsnKG/OwsCwsLzC8usjA/i6Z6aLKNrrlUSjtMTWZZWpjh1Kk82WyGW3du8fu//wcMJZkfvflj1GiE\n3OwUuUKOYvkARYJOvUZuqsDR0SGJZIyNjXXAo1gq4uKPa2RV5saNj8nlc+TzeW7fvs3R4SELC/N8\n8MEH9AcDzGic1qgrk0gmOLN8htlTp5BcFwWHhfkZ6ocVVDxavS6/93v/nI8+eo+jSolet4WimQz6\nQ3724cfcvn+Pge3wyeef03McbMlldnGBmXyBxfkFokYEu9/j3DPfPvkB/O0fv/5aJp1iduYUmqqA\n5+E6Q2JmlGan5VdDI3W3394bjtzYfFFQvV4ftfiGQQAXSmDRrjvuihZccvJcPNxACW2NZkS27e9q\n+/eR1UBAFY1GUTUJVfVNVlKp5Eg57mJbNoPBEwet44FKVVViZjSohDod/9SlfewClaiYxecDvuIn\nLWbYYpYrPpfredgjJbxhGAxsC5knZ0uFb3jw0h79HULRLUYRiqLQ7vk+3vZoxxn81mbMMFEk2beu\nTCf9cYbsq5pVRSEei2NbFpruXztzPJfd3V0kCKrRVqtFt+PPYUV7XKjT/XHHENf11deFwhSa5u8M\nK7JCu9Fif/8AF49bd+/Q6bQ5OqoErfZAwd1poyoqzWaLbrdLpVIJgnW73Q52xxuNBuDvdqdSKSQZ\nDNNXxBpGhNxkjlwuh2maZDIZFEUmmUwF4wMh8hOBdzi0Ai2G41hY1gBZ9rs4tVp9tFufRpb9S2l+\nJasG2wxAoCmwLCtQq4MUjFeE0E+sRMZisUB4JssS8bh/Sc0wDZyhH5zFURphHiPm78IT3tdE9BkO\nbZzRjL3X6yIsV4VL3XBoo0c0BtYg2N8XIs6xsbHRMRIpEH0CxKIxHMcNuhaSJK66DclOZJmcnGQ4\ntOl2ukRjJrIq0Ww20LQI/V6fSqlIo9nhe9/7DSbScbo9Pxl4//33aXfadLod5ucXmJoq0Ku30CMR\nPv/iM5rNJjOzMywsLKHqOrIeoTA5yd2bNzkslZicmqRUKfHKq6/ieh71ep1HDx+ysrpKv+efmH3z\nzTd5+umn2dvZ5fr1azSadRrtFrmpPHMLc7z43IvcuXmLO7fv4OHxwte/TqvRZHNzk/mlJTRZ5rMv\nPuPMmdMoqsxEfhKr22U8O8biwhLlcplkKo2MB0OH4dBme3eH7Y198GR0TafWbLG0vMz+7h47uzvc\nufUAe+Cwv3/AN77xTf7jf/rPXLp0jatXn+H02VW+/4PvUy6XWVtZYXFxgWajTnY8iyz7nRBhVCRG\nT9vb23RGmyC1apVy+YDF+Tnu3rmN4zicXj7D1u4ODx89YnVtjcFgwPqjB2w+foQuS6BKtHo9Gp0u\ntXoVM6KxsnKGymGFZrPOn/zxfycZi6HICpIMjUadXD7H6uoqtVqdiYksvV6HSrnMU1cu8tZbb3Lq\n1DTPP/8srVaLVCpBv9elXq1ydFRlZ3ePZCLK7bs3iSdiPHX9Kq1mk1Qsjq4o5PI5trY2efjgIZMT\nE1Rrh5w9e4bV1TUcZ9R1yU5QrVaJxWKBYNFxHP98rW6ysbHF4uIii0vL1OoN9FGhlIzHSKWT2FaP\nXrdLt9smPTnOD//0T1lemKPXa3Pp4nmGQxkzlqRcLDE7M4PjuRzWa1z72te5eesOZizOTGGah48e\n4AxtPv/iM7756//w5AfwX3z4/mvJ0fxavBDF/FNRFBzLwhvteXuuS7fdBU/6ijmGCJTiDrFQlwJf\naVM2m01UVSWTydBqNfGPQfinPT3vyQEMRVaIRIygbe7/HaIFrOI4Lrrut6jxhAubb1Ai2rZivgqg\nyP7dajGL9mS/1e4IMZb0xJ9cGGwoihK4RgHB/FvM3vv9Poqqkhjt7Xa7XRqtJsl4IkgkjrtsCdWv\nqJaEhzUQWLWKeb0zEpu1Wy1wXPA8VE3lsFYN2vXlkr8S0u10aTQaeIwMTLr+MRpNVbEGAybGszj2\nMLjhLUYKImHJ5XJIki8UM6OR0fciETVjRM0YqqwTjcVJppOMZbOkU75Dkj8OcfANVoSoUKHT6eJf\nGPP/vfF4PFibE7NXf75rjnafjWA/20/6msiyhOM6WNaAeDxGZ3QxKxLR6fX6gfDLn3/LwY1vx7FH\nWgTfXU/XhFDQCZT6uq5Tr9eDlUVR7Qrtw/GNA/+78piczOG6HrIsBc+08LbXNBXLGjzRdOCNnqMO\nmiaS3ifbBkInEo/GUGQZVVHpDwa4njt65p3gWfNHRzaqpqIoEoYRwfN8d0B/rU4OTuQeV3H3e33f\nUGYk8tR1nUajhqb7SU+tVht1pyw0XaNWa4DrYpoxWvUGmUSC+fl56rUaz1+/Qq/TZXI8S6vewB06\nXLl0mbPLp3HsIZPjE5RLZSYmxvnN7/1d7t+7y8PH62xsbvHOT94kN5Hl5Ree5+jI3x0+ffoMvX4f\nyxnys599yHe/+10G/QGzMzNsbGwwOzuLaZok4gnq9TpffP4FrU6bjfV1jsqH2P0enm2zub6OHtGZ\nn52jdFCkVCnz5f27pGMmi0sLdNsdpmemyU8ViBkROr0eDx88ZPn0GVRdR5VlopEIqizT6nZJJsa5\nfOUKnqLy1NPPMBy6WP0+ly9fIqJqTOYm+Hu/9T084MMbn3Bqeo5kcpx/9a//Le7QJmYa5PNTnDl7\nmpmZGXr9HpIn4Tq+ALNULOM4HroWodXqkIjHqFerRI0IrYZ/M1zTND759EtW1s6xunaOdDqDO9K2\nuM6QyYkx8pMT3L13j7GJCTKTUxR39sjnshRyeS5fuczs3AwrZ09jDfo89/VnuX37JmfOnCUWi+J5\nEqeXT+M4DrMzc1SPjpjI5chN5kmmUmzv7LK4sMDhYRlTV1h//IC56WkG/T5Li7Pk8jmGzsA3FYrH\nyE/mONgvgiRRrVY5OjrkwsVzJBMJ/1Ke5Xfkbtz4mKHtfMXxsdlsMn1qipWzq8EJ53Q6w/vvv4cZ\n90W41WqVmVMF7t+/S2YsQSRiUClXQNO4efMzLl9Y486dW1y9chlP0oknx5ienKTZarC7t8PswgJb\n2wfcufsAz5W4desLTEOn3qgxXchz7eVfO/kB/IP33nptMBhQq9VIJpP0er7jl2majKXTfhtRUTEN\nk0Q8TjKe9FWUo91f0f4UojHP86hWq8FaVrlcDpIBsdvt36ZOYkZNLGswmg1GAhW0bQ/RND1Q4fqZ\nq18RKiOleLfTC+4xy7IavHSFUOq4glqcTQxWuDQ1mN27o9m3cAoT8/beqCI47nF9fFddWGYycm1L\nJBL0BwM01b/0Jartdrsd3BYvlUrBy7nf79Nqtfz5bCz6lV1kD1+56bouMcNEAjrdLsi+OC2ZTPpi\nN8MgHouTyvi+z5nR9zWRzQYnOxPxBIosY9lWsAVwPCkBXwvQ6XSwhwMUxX/pq4pKr9vDjEbxJI9u\nr4esSVgDC3VUSY6NZUinxwKhW3d0tCYWi5NMJoIjKCKRErvowuUukUigqE/ubne7XQaDHtPTBTTN\nD7T+psCQiBHBHtrAk4ts3mhHy7/n7tDudIjH/Tm147i4njsyUnEDkSAQqLGFIO+4j7j445u6OFiW\nTb/vazGE+l3s0VerVTqdNpGIjqL4pxjFkRDw3bUMwyCTyXxlEwBgaItrbxDRIyiSAtKT4zdPRJh9\nFFUZ/T64o26Gf8lNCPNEshyPxwFoNVuMj2eDKt51XRqNOpGIzmDQIxLxd9GR/CRT0yNEdB0PhVQ8\njmsPuP/oIelknFpph6PyEWfOnqFcKrG6uko2Pc5f/eUbbK1vcuXyZX7xySf81m/+BpVSkbnZGWRF\nxzBNFufmiUcNbnz8EZcunveT34hvJ7uxtcnLL7+MgsTe9g5Xrlyh1+uxtrbmK/BdjxsffUQ+l2N5\ncYneoM/MqRkOi0XG0hkWFxao1g65d+cOjXqTVqdNuXrI9cuXefT4EZl0CkVT6doWE5lxshNZSsUS\nR9U6nX6Xq5eu0Gs1se2h3/KfzCOrKpFolHarz90793j1V75Nt99lfnaazHiKtXNrvP7GG3zrle/w\n1lvvcOPGDe7dvc8r336Fbq/D0uklZmZm2d7eYnwyi6GbPHj0CNOMEovFqdX8e+Xz83N8/LOfUchP\n0em2mZz076JPFQrIsorn+YleLpdnfX2Do2qV8bEUY2MZXMchHosxWSgwNbfIl7/4nzz9zDX6nS7l\nSonl00u4to3n+AecqqM75QPLolGvk4gluXnzDnu7e/StAZtbG0xNzzCeHWcqN8XGxjpx08Qa9FAV\nhUG3S3G/SERX+fTTT/jWt7/FwuIiUSOKofodm7fefovl5WXGx8fY29tlYmKcYrGEZVk8frROrVpj\nYjJLq9Wm3++zuLjI/v4+lfIhAN1uj1qtxtTUlH/Nz3FYXV0lnfa9SDbWHzI9e4pet0uj2UY1TH79\n1/423VaTcyun2ds9wHFVPvvyJoN2h6mpSTRVZW5+gS9u3eXKlafo9yy2N9dZO7/GWCZFYSrPyrX/\nsxn4/xPHTEJCQkJCQkL+Zsj/tz9ASEhISEhIyN+cMICHhISEhIScQMIAHhISEhIScgIJA3hISEhI\nSMgJJAzgISEhISEhJ5AwgIeEhISEhJxAwgAeEhISEhJyAgkDeEhISEhIyAkkDOAhISEhISEnkDCA\nh4SEhISEnEDCAB4SEhISEnICCQN4SEhISEjICSQM4CEhISEhISeQMICHhISEhIScQMIAHhISEhIS\ncgIJA3hISEhISMgJJAzgISEhISEhJ5AwgIeEhISEhJxAwgAeEhISEhJyAgkDeEhISEhIyAkkDOAh\nISEhISEnkDCAh4SEhISEnEDCAB4SEhISEnIC+V8eTzOqGmLORQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "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": [ + "" + ] + }, + "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": [ + "" + ] + }, + "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/data/lib_coco/PythonAPI/pycocoEvalDemo.ipynb b/data/lib_coco/PythonAPI/pycocoEvalDemo.ipynb new file mode 100644 index 0000000..26844f6 --- /dev/null +++ b/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/data/lib_coco/PythonAPI/pycocotools/__init__.py b/data/lib_coco/PythonAPI/pycocotools/__init__.py new file mode 100644 index 0000000..c84c021 --- /dev/null +++ b/data/lib_coco/PythonAPI/pycocotools/__init__.py @@ -0,0 +1 @@ +__author__ = 'tylin' diff --git a/data/lib_coco/PythonAPI/pycocotools/_mask.c b/data/lib_coco/PythonAPI/pycocotools/_mask.c new file mode 100644 index 0000000..5c07d55 --- /dev/null +++ b/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 +#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 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 +#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 +#include +#include +#include "numpy/arrayobject.h" +#include "numpy/ufuncobject.h" +#include "maskApi.h" +#ifdef _OPENMP +#include +#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 + #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 + #else + #include + #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 + +/* 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 +#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.._len"; +static const char __pyx_k_frUncompressedRLE[] = "frUncompressedRLE"; +static const char __pyx_k_iou_locals__bbIou[] = "iou.._bbIou"; +static const char __pyx_k_pycocotools__mask[] = "pycocotools._mask"; +static const char __pyx_k_iou_locals__rleIou[] = "iou.._rleIou"; +static const char __pyx_k_iou_locals__preproc[] = "iou.._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 = 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 = 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 = 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 = 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 = 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] = 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] = 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] = 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] = 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( &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( &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( &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( &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( &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( &Rs._R[i], 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( &Rs._R[i], 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( &Rs._R[i], 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( &Rs._R[i], 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,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,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,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,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,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(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(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(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(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(Rs._R, R._R, 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(Rs._R, R._R, 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(Rs._R, R._R, 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(Rs._R, R._R, 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(Rs._R, R._R, 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 = 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 = 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 = 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 = malloc(Rs._n* sizeof(uint)) + * rleArea(Rs._R, Rs._n, _a) # <<<<<<<<<<<<<< + * cdef np.npy_intp shape[1] + * shape[0] = 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] = 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] = 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] = 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 = 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( dt._R, gt._R, m, n, iscrowd.data, _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( dt._R, gt._R, m, n, iscrowd.data, _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( dt._R, gt._R, m, n, iscrowd.data, _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( dt.data, gt.data, m, n, iscrowd.data, _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( dt._R, gt._R, m, n, iscrowd.data, _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( dt._R, gt._R, m, n, iscrowd.data, _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( dt.data, gt.data, m, n, iscrowd.data, _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( dt._R, gt._R, m, n, iscrowd.data, _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( dt.data, gt.data, m, n, iscrowd.data, _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( dt._R, gt._R, m, n, iscrowd.data, _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( dt.data, gt.data, m, n, iscrowd.data, _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( dt.data, gt.data, m, n, iscrowd.data, _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( dt.data, gt.data, m, n, iscrowd.data, _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( dt.data, gt.data, m, n, iscrowd.data, _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( dt._R, gt._R, m, n, iscrowd.data, _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( dt._R, gt._R, m, n, iscrowd.data, _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( dt.data, gt.data, m, n, iscrowd.data, _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( dt.data, gt.data, m, n, iscrowd.data, _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 = 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 = 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 = malloc(m*n* sizeof(double)) # <<<<<<<<<<<<<< + * iou = np.zeros((m*n, ), dtype=np.double) + * shape[0] = 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 = malloc(m*n* sizeof(double)) + * iou = np.zeros((m*n, ), dtype=np.double) # <<<<<<<<<<<<<< + * shape[0] = 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 = malloc(m*n* sizeof(double)) + * iou = np.zeros((m*n, ), dtype=np.double) + * shape[0] = 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] = 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] = 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 = 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 = malloc(4*n* sizeof(double)) + * rleToBbox( 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 = malloc(4*n* sizeof(double)) # <<<<<<<<<<<<<< + * rleToBbox( 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 = malloc(4*n* sizeof(double)) + * rleToBbox( Rs._R, _bb, n ) # <<<<<<<<<<<<<< + * cdef np.npy_intp shape[1] + * shape[0] = 4*n + */ + rleToBbox(((RLE const *)__pyx_v_Rs->_R), __pyx_v__bb, __pyx_v_n); + + /* "pycocotools/_mask.pyx":247 + * rleToBbox( Rs._R, _bb, n ) + * cdef np.npy_intp shape[1] + * shape[0] = 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] = 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] = 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( Rs._R, 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( Rs._R, 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( Rs._R, 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( Rs._R, 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( Rs._R, 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( &Rs._R[i], 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( &Rs._R[i], 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( &Rs._R[i], 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( &Rs._R[i], 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( &Rs._R[i], 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( &Rs._R[i], 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 = 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 = malloc(len(cnts)* sizeof(uint)) # <<<<<<<<<<<<<< + * for j in range(len(cnts)): + * data[j] = 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 = malloc(len(cnts)* sizeof(uint)) + * for j in range(len(cnts)): # <<<<<<<<<<<<<< + * data[j] = cnts[j] + * R = RLE(ucRles[i]['size'][0], ucRles[i]['size'][1], len(cnts), 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 = malloc(len(cnts)* sizeof(uint)) + * for j in range(len(cnts)): + * data[j] = cnts[j] # <<<<<<<<<<<<<< + * R = RLE(ucRles[i]['size'][0], ucRles[i]['size'][1], len(cnts), 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] = cnts[j] + * R = RLE(ucRles[i]['size'][0], ucRles[i]['size'][1], len(cnts), 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] = cnts[j] + * R = RLE(ucRles[i]['size'][0], ucRles[i]['size'][1], len(cnts), 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), 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 = ((&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 = ((&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 = ((&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 = stdlib.malloc(sizeof(Py_ssize_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 = stdlib.malloc(sizeof(Py_ssize_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 = stdlib.malloc(sizeof(Py_ssize_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 = 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 = PyArray_STRIDES(self) # <<<<<<<<<<<<<< + * info.shape = 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 = PyArray_STRIDES(self) + * info.shape = 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 = PyArray_STRIDES(self) + * info.shape = 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 = 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 = 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 = 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 = 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 = 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, 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, 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, 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, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, 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, a, 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, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, 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, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, 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, a, b, 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, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, 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, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, 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, a, b, c, 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, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, 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, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, 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, a, b, c, d, 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, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, 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, a, b, c, d, 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 = ((&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 = ((&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) - (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) - (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) - (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) - (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, a, b, c, d, 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 = 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 = 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 = 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 = 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 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 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( &Rs._R[i], 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(Rs._R, R._R, 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( dt._R, gt._R, m, n, iscrowd.data, _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( dt._R, gt._R, m, n, iscrowd.data, _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( dt.data, gt.data, m, n, iscrowd.data, _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( dt.data, gt.data, m, n, iscrowd.data, _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 = 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) - (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 = 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 = 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("", + op->func_qualname, (void *)op); +#else + return PyString_FromFormat("", + 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/data/lib_coco/PythonAPI/pycocotools/_mask.pyx b/data/lib_coco/PythonAPI/pycocotools/_mask.pyx new file mode 100644 index 0000000..1ea002a --- /dev/null +++ b/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 = 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] = 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( &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( &Rs._R[i], 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,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(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(Rs._R, R._R, Rs._n, intersect) + obj = _toString(R)[0] + return obj + +def area(rleObjs): + cdef RLEs Rs = _frString(rleObjs) + cdef uint* _a = malloc(Rs._n* sizeof(uint)) + rleArea(Rs._R, Rs._n, _a) + cdef np.npy_intp shape[1] + shape[0] = 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( dt._R, gt._R, m, n, iscrowd.data, _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( dt.data, gt.data, m, n, iscrowd.data, _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 = 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 = malloc(m*n* sizeof(double)) + iou = np.zeros((m*n, ), dtype=np.double) + shape[0] = 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 = malloc(4*n* sizeof(double)) + rleToBbox( Rs._R, _bb, n ) + cdef np.npy_intp shape[1] + shape[0] = 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( Rs._R, 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( &Rs._R[i], 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 = malloc(len(cnts)* sizeof(uint)) + for j in range(len(cnts)): + data[j] = cnts[j] + R = RLE(ucRles[i]['size'][0], ucRles[i]['size'][1], len(cnts), 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/data/lib_coco/PythonAPI/pycocotools/coco.py b/data/lib_coco/PythonAPI/pycocotools/coco.py new file mode 100644 index 0000000..a7611a6 --- /dev/null +++ b/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/data/lib_coco/PythonAPI/pycocotools/cocoeval.py b/data/lib_coco/PythonAPI/pycocotools/cocoeval.py new file mode 100644 index 0000000..69ef890 --- /dev/null +++ b/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[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[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/data/lib_coco/PythonAPI/pycocotools/mask.py b/data/lib_coco/PythonAPI/pycocotools/mask.py new file mode 100644 index 0000000..eb9e3c1 --- /dev/null +++ b/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/data/lib_coco/PythonAPI/setup.py b/data/lib_coco/PythonAPI/setup.py new file mode 100644 index 0000000..7b142c8 --- /dev/null +++ b/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/data/lib_coco/__init__.py b/data/lib_coco/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/data/lib_coco/common/gason.cpp b/data/lib_coco/common/gason.cpp new file mode 100644 index 0000000..cd27a8d --- /dev/null +++ b/data/lib_coco/common/gason.cpp @@ -0,0 +1,335 @@ +// https://github.com/vivkin/gason - pulled January 10, 2016 +#include "gason.h" +#include + +#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/data/lib_coco/common/gason.h b/data/lib_coco/common/gason.h new file mode 100644 index 0000000..508eda5 --- /dev/null +++ b/data/lib_coco/common/gason.h @@ -0,0 +1,136 @@ +// https://github.com/vivkin/gason - pulled January 10, 2016 +#pragma once + +#include +#include +#include + +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/data/lib_coco/common/maskApi.c b/data/lib_coco/common/maskApi.c new file mode 100644 index 0000000..768100a --- /dev/null +++ b/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 +#include + +uint umin( uint a, uint b ) { return (ab) ? 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; jcnts[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; i0 ) { + c=umin(ca,cb); cc+=c; ct=0; + ca-=c; if(!ca && a0) { + 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 && athr) 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; gthr) keep[j]=0; + } + } +} + +void rleToBbox( const RLE *R, BB bb, siz n ) { + siz i; for( i=0; id?1:c=dy && xs>xe) || (dxye); + 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; jw-1 ) continue; + yd=(double)(v[j]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; j0) b[m++]=a[j++]; else { + j++; if(jm, p=0; long x; int more; + char *s=malloc(sizeof(char)*m*6); + for( i=0; icnts[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/data/lib_coco/common/maskApi.h b/data/lib_coco/common/maskApi.h new file mode 100644 index 0000000..4ddf723 --- /dev/null +++ b/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/data/lib_coco/get_coco_next_batch.py b/data/lib_coco/get_coco_next_batch.py new file mode 100644 index 0000000..0f470ea --- /dev/null +++ b/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/data/pretrained_weights/README.md b/data/pretrained_weights/README.md new file mode 100644 index 0000000..e1bb9b0 --- /dev/null +++ b/data/pretrained_weights/README.md @@ -0,0 +1,2 @@ +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. +2、Or you can choose to use a better backbone, refer to [gluon2TF](https://github.com/yangJirui/gluon2TF). [Pretrain Model Link](https://pan.baidu.com/s/1GpqKg0dOaaWmwshvv1qWGg), password: 5ht9. diff --git a/help_utils/__init__.py b/help_utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/help_utils/tools.py b/help_utils/tools.py new file mode 100644 index 0000000..f53f5e9 --- /dev/null +++ b/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/libs/__init__.py b/libs/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/libs/box_utils/__init__.py b/libs/box_utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/libs/box_utils/anchor_utils.py b/libs/box_utils/anchor_utils.py new file mode 100644 index 0000000..2de4abf --- /dev/null +++ b/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 +import sys +sys.path.append('../..') + +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 + + 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 = 32 + anchor_scales = [2 ** 0, 2 ** (1.0 / 3.0), 2 ** (2.0 / 3.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=512, + featuremap_height=512, + stride=8) + init = tf.global_variables_initializer() + with tf.Session() as sess: + sess.run(init) + anchor_result = sess.run(anchors) + print(anchor_result[:10]) + diff --git a/libs/box_utils/bbox_transform.py b/libs/box_utils/bbox_transform.py new file mode 100644 index 0000000..e1b713c --- /dev/null +++ b/libs/box_utils/bbox_transform.py @@ -0,0 +1,66 @@ +# -*- 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 bbox_transform_inv(boxes, deltas, scale_factors=None): + dx = deltas[:, 0] + dy = deltas[:, 1] + dw = deltas[:, 2] + dh = deltas[:, 3] + + if scale_factors: + dx /= scale_factors[0] + dy /= scale_factors[1] + dw /= scale_factors[2] + dh /= scale_factors[3] + + widths = boxes[:, 2] - boxes[:, 0] + 1.0 + heights = boxes[:, 3] - boxes[:, 1] + 1.0 + ctr_x = boxes[:, 0] + 0.5 * widths + ctr_y = boxes[:, 1] + 0.5 * heights + + 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 + + predict_xmin = pred_ctr_x - 0.5 * pred_w + predict_xmax = pred_ctr_x + 0.5 * pred_w + predict_ymin = pred_ctr_y - 0.5 * pred_h + predict_ymax = pred_ctr_y + 0.5 * pred_h + + return tf.transpose(tf.stack([predict_xmin, predict_ymin, + predict_xmax, predict_ymax])) + + +def bbox_transform(ex_rois, gt_rois, scale_factors=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_factors: + targets_dx *= scale_factors[0] + targets_dy *= scale_factors[1] + targets_dw *= scale_factors[2] + targets_dh *= scale_factors[3] + + targets = np.vstack((targets_dx, targets_dy, targets_dw, targets_dh)).transpose() + + return targets diff --git a/libs/box_utils/boxes_utils.py b/libs/box_utils/boxes_utils.py new file mode 100644 index 0000000..578f694 --- /dev/null +++ b/libs/box_utils/boxes_utils.py @@ -0,0 +1,111 @@ +# -*- 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(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 = boxes[:, 0] + ymin = boxes[:, 1] + xmax = boxes[:, 2] + ymax = 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/libs/box_utils/cython_utils/Makefile b/libs/box_utils/cython_utils/Makefile new file mode 100644 index 0000000..1b9f188 --- /dev/null +++ b/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/libs/box_utils/cython_utils/__init__.py b/libs/box_utils/cython_utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/libs/box_utils/cython_utils/bbox.c b/libs/box_utils/cython_utils/bbox.c new file mode 100644 index 0000000..f32c0c4 --- /dev/null +++ b/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 +#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 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 +#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 +#include +#include +#include "numpy/arrayobject.h" +#include "numpy/ufuncobject.h" +#ifdef _OPENMP +#include +#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 + #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 + #else + #include + #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 = ((&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 = ((&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 = ((&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 = stdlib.malloc(sizeof(Py_ssize_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 = stdlib.malloc(sizeof(Py_ssize_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 = stdlib.malloc(sizeof(Py_ssize_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 = 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 = PyArray_STRIDES(self) # <<<<<<<<<<<<<< + * info.shape = 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 = PyArray_STRIDES(self) + * info.shape = 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 = PyArray_STRIDES(self) + * info.shape = 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 = 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 = 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 = 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 = 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 = 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, 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, 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, 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, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, 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, a, 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, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, 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, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, 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, a, b, 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, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, 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, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, 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, a, b, c, 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, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, 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, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, 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, a, b, c, d, 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, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, 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, a, b, c, d, 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 = ((&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 = ((&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) - (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) - (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) - (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) - (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, a, b, c, d, 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 = 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 = 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 = 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 = 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 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 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) - (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/libs/box_utils/cython_utils/bbox.pyx b/libs/box_utils/cython_utils/bbox.pyx new file mode 100644 index 0000000..70a9b3f --- /dev/null +++ b/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/libs/box_utils/cython_utils/nms.c b/libs/box_utils/cython_utils/nms.c new file mode 100644 index 0000000..c72d736 --- /dev/null +++ b/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 +#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 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 +#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 +#include +#include +#include "numpy/arrayobject.h" +#include "numpy/ufuncobject.h" +#ifdef _OPENMP +#include +#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 + #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 + #else + #include + #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 = ((&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 = ((&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 = ((&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 = stdlib.malloc(sizeof(Py_ssize_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 = stdlib.malloc(sizeof(Py_ssize_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 = stdlib.malloc(sizeof(Py_ssize_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 = 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 = PyArray_STRIDES(self) # <<<<<<<<<<<<<< + * info.shape = 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 = PyArray_STRIDES(self) + * info.shape = 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 = PyArray_STRIDES(self) + * info.shape = 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 = 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 = 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 = 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 = 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 = 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, 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, 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, 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, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, 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, a, 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, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, 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, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, 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, a, b, 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, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, 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, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, 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, a, b, c, 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, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, 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, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, 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, a, b, c, d, 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, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, 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, a, b, c, d, 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 = ((&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 = ((&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) - (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) - (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) - (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) - (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, a, b, c, d, 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 = 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 = 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 = 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 = 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 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 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) - (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/libs/box_utils/cython_utils/nms.pyx b/libs/box_utils/cython_utils/nms.pyx new file mode 100644 index 0000000..be1a1a3 --- /dev/null +++ b/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/libs/box_utils/cython_utils/setup.py b/libs/box_utils/cython_utils/setup.py new file mode 100644 index 0000000..aff56a8 --- /dev/null +++ b/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/libs/box_utils/draw_box_in_img.py b/libs/box_utils/draw_box_in_img.py new file mode 100644 index 0000000..b9e2836 --- /dev/null +++ b/libs/box_utils/draw_box_in_img.py @@ -0,0 +1,162 @@ +# -*- 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, x+60, y+10], + fill=color) + draw_obj.text(xy=(x, y), + text="obj:" +str(round(score, 2)), + fill='black', + 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, x + 60, y + 10], + fill=color) + + txt = LABEL_NAME_MAP[label] + ':' + str(round(score, 2)) + draw_obj.text(xy=(x, y), + text=txt, + fill='black', + font=FONT) + + +def draw_boxes_with_label_and_scores(img_array, boxes, labels, scores, in_graph=True): + if in_graph: + if cfgs.NET_NAME in ['resnet152_v1d', 'resnet101_v1d', 'resnet50_v1d']: + img_array = (img_array * np.array(cfgs.PIXEL_STD) + np.array(cfgs.PIXEL_MEAN_)) * 255 + else: + 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) + 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='White') + continue + else: + draw_label_with_scores(draw_obj, box, a_label, a_score, color='White') + + 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/libs/box_utils/generate_anchors.py b/libs/box_utils/generate_anchors.py new file mode 100755 index 0000000..c45ae67 --- /dev/null +++ b/libs/box_utils/generate_anchors.py @@ -0,0 +1,148 @@ +# -------------------------------------------------------- +# Faster R-CNN +# Copyright (c) 2015 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ross Girshick and Sean Bell +# -------------------------------------------------------- +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import numpy as np + + +# Verify that we compute the same anchors as Shaoqing's matlab implementation: +# +# >> load output/rpn_cachedir/faster_rcnn_VOC2007_ZF_stage1_rpn/anchors.mat +# >> anchors +# +# anchors = +# +# -83 -39 100 56 +# -175 -87 192 104 +# -359 -183 376 200 +# -55 -55 72 72 +# -119 -119 136 136 +# -247 -247 264 264 +# -35 -79 52 96 +# -79 -167 96 184 +# -167 -343 184 360 + +# array([[ -83., -39., 100., 56.], +# [-175., -87., 192., 104.], +# [-359., -183., 376., 200.], +# [ -55., -55., 72., 72.], +# [-119., -119., 136., 136.], +# [-247., -247., 264., 264.], +# [ -35., -79., 52., 96.], +# [ -79., -167., 96., 184.], +# [-167., -343., 184., 360.]]) + +def gereate_centering_anchor( + base_size=16, ratios=[0.5, 1, 2], + scales=2 ** np.arange(3, 6)): + + """ + Generate anchor (reference) windows by enumerating aspect ratios X + scales wrt a reference (0, 0, 15, 15) window. + """ + base_anchor = np.array([1, 1, base_size, base_size]) - (base_size // 2) + ratio_anchors = _ratio_enum(base_anchor, ratios) + anchors = np.vstack([_scale_enum(ratio_anchors[i, :], scales) + for i in range(ratio_anchors.shape[0])]) + return anchors.astype(np.float32) + +def generate_anchors(base_size=16, ratios=[0.5, 1, 2], + scales=2 ** np.arange(3, 6)): + """ + Generate anchor (reference) windows by enumerating aspect ratios X + scales wrt a reference (0, 0, 15, 15) window. + """ + + base_anchor = np.array([1, 1, base_size, base_size]) - 1 + ratio_anchors = _ratio_enum(base_anchor, ratios) + anchors = np.vstack([_scale_enum(ratio_anchors[i, :], scales) + for i in range(ratio_anchors.shape[0])]) + return anchors.astype(np.float32) + + +def _whctrs(anchor): + """ + Return width, height, x center, and y center for an anchor (window). + """ + + w = anchor[2] - anchor[0] + 1 + h = anchor[3] - anchor[1] + 1 + x_ctr = anchor[0] + 0.5 * (w - 1) + y_ctr = anchor[1] + 0.5 * (h - 1) + return w, h, x_ctr, y_ctr + + +def _mkanchors(ws, hs, x_ctr, y_ctr): + """ + Given a vector of widths (ws) and heights (hs) around a center + (x_ctr, y_ctr), output a set of anchors (windows). + """ + + ws = ws[:, np.newaxis] + hs = hs[:, np.newaxis] + anchors = np.hstack((x_ctr - 0.5 * (ws - 1), + y_ctr - 0.5 * (hs - 1), + x_ctr + 0.5 * (ws - 1), + y_ctr + 0.5 * (hs - 1))) + return anchors + + +def _ratio_enum(anchor, ratios): + """ + Enumerate a set of anchors for each aspect ratio wrt an anchor. + """ + + w, h, x_ctr, y_ctr = _whctrs(anchor) + size = w * h + size_ratios = size / ratios + ws = np.round(np.sqrt(size_ratios)) + hs = np.round(ws * ratios) + anchors = _mkanchors(ws, hs, x_ctr, y_ctr) + return anchors + + +def _scale_enum(anchor, scales): + """ + Enumerate a set of anchors for each scale wrt an anchor. + """ + + w, h, x_ctr, y_ctr = _whctrs(anchor) + ws = w * scales + hs = h * scales + anchors = _mkanchors(ws, hs, x_ctr, y_ctr) + return anchors + + +def generate_anchors_pre(height, width, feat_stride, anchor_scales=(8, 16, 32), + anchor_ratios=(0.5, 1, 2), base_size=16): + """ A wrapper function to generate anchors given different scales + Also return the number of anchors in variable 'length' + """ + anchors = generate_anchors( + base_size=base_size, ratios=np.array(anchor_ratios), + scales=np.array(anchor_scales)) + A = anchors.shape[0] + shift_x = np.arange(0, width) * feat_stride + shift_y = np.arange(0, height) * feat_stride + shift_x, shift_y = np.meshgrid(shift_x, shift_y) + shifts = np.vstack((shift_x.ravel(), shift_y.ravel(), shift_x.ravel(), + shift_y.ravel())).transpose() + K = shifts.shape[0] + # width changes faster, so here it is H, W, C + anchors = anchors.reshape((1, A, 4)) + shifts.reshape((1, K, 4)).transpose( + (1, 0, 2)) + anchors = anchors.reshape((K * A, 4)).astype(np.float32, copy=False) + + return anchors + + +if __name__ == '__main__': + anchors = generate_anchors_pre(64, 64, 8, anchor_scales=np.array([2 ** 0, 2 ** (1.0 / 3.0), 2 ** (2.0 / 3.0)]) * 8, + anchor_ratios=(0.5, 1.0, 2.0), base_size=4) + print(anchors[:10]) diff --git a/libs/box_utils/show_box_in_tensor.py b/libs/box_utils/show_box_in_tensor.py new file mode 100644 index 0000000..8cef7a5 --- /dev/null +++ b/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 + +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/libs/box_utils/tf_ops.py b/libs/box_utils/tf_ops.py new file mode 100644 index 0000000..f4e0ac0 --- /dev/null +++ b/libs/box_utils/tf_ops.py @@ -0,0 +1,39 @@ +# -*- 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]) \ No newline at end of file diff --git a/libs/configs/__init__.py b/libs/configs/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/libs/configs/cfgs.py b/libs/configs/cfgs.py new file mode 100644 index 0000000..c7f817e --- /dev/null +++ b/libs/configs/cfgs.py @@ -0,0 +1,116 @@ +# -*- coding: utf-8 -*- +from __future__ import division, print_function, absolute_import +import os +import tensorflow as tf +import math + +""" +cls : train|| Recall: 0.9574468085106383 || Precison: 0.011264550043806583|| AP: 0.8429614751356598 +cls : boat|| Recall: 0.9619771863117871 || Precison: 0.005608636857389878|| AP: 0.7247602142711771 +cls : motorbike|| Recall: 0.9938461538461538 || Precison: 0.00780136705069681|| AP: 0.8620336717055882 +cls : aeroplane|| Recall: 0.968421052631579 || Precison: 0.015942698706099816|| AP: 0.877200533188366 +cls : person|| Recall: 0.9882950530035336 || Precison: 0.031197060853440043|| AP: 0.8549563913368059 +cls : pottedplant|| Recall: 0.9145833333333333 || Precison: 0.006810847710065781|| AP: 0.5597989508143375 +cls : sofa|| Recall: 0.99581589958159 || Precison: 0.004477303083319224|| AP: 0.7809330043853933 +cls : car|| Recall: 0.9900083263946711 || Precison: 0.015191781872077275|| AP: 0.8929651092188676 +cls : cat|| Recall: 0.994413407821229 || Precison: 0.0132925098947054|| AP: 0.8900856486739736 +cls : horse|| Recall: 0.9913793103448276 || Precison: 0.009228793836770725|| AP: 0.8822391183389151 +cls : tvmonitor|| Recall: 0.961038961038961 || Precison: 0.006890771952695782|| AP: 0.7956874756219561 +cls : sheep|| Recall: 0.9834710743801653 || Precison: 0.008470956719817768|| AP: 0.847823073416635 +cls : dog|| Recall: 0.9959100204498977 || Precison: 0.0186640095044648|| AP: 0.8711714077751838 +cls : bus|| Recall: 0.9859154929577465 || Precison: 0.006062180652983459|| AP: 0.8646568186454162 +cls : chair|| Recall: 0.9708994708994709 || Precison: 0.007137300661221315|| AP: 0.6544968051248526 +cls : bicycle|| Recall: 0.9881305637982196 || Precison: 0.00703704486380254|| AP: 0.8543458412723929 +cls : bird|| Recall: 0.9760348583877996 || Precison: 0.016314639475600873|| AP: 0.8255116265985485 +cls : diningtable|| Recall: 0.9854368932038835 || Precison: 0.0024620086594787332|| AP: 0.7423151271987897 +cls : bottle|| Recall: 0.9381663113006397 || Precison: 0.0067838421214924454|| AP: 0.7201777267756303 +cls : cow|| Recall: 0.9959016393442623 || Precison: 0.00847162181006833|| AP: 0.8656722996831789 +mAP is : 0.8104896159590833 (pascal_430040model.ckpt) + +""" + +# ------------------------------------------------ +VERSION = 'RetinaNet_VOC0712_20190524' +NET_NAME = 'resnet101_v1d' # 'MobilenetV2' +ADD_BOX_IN_TENSORBOARD = True + +# ---------------------------------------- System_config +ROOT_PATH = os.path.abspath('../') +print(20*"++--") +print(ROOT_PATH) +GPU_GROUP = "0,1,2,3,4,5,6,7" +NUM_GPU = len(GPU_GROUP.strip().split(',')) +SHOW_TRAIN_INFO_INTE = 10 +SMRY_ITER = 100 +SAVE_WEIGHTS_INTE = (11540 + 5000) * 2 + +SUMMARY_PATH = ROOT_PATH + '/output/summary' +TEST_SAVE_PATH = ROOT_PATH + '/tools/test_result' + +if NET_NAME.startswith("resnet"): + weights_name = NET_NAME +elif NET_NAME.startswith("MobilenetV2"): + weights_name = "mobilenet/mobilenet_v2_1.0_224" +else: + raise Exception('net name must in [resnet_v1_101, resnet_v1_50, MobilenetV2]') + +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/' + +# ------------------------------------------ Train config +RESTORE_FROM_RPN = False +FIXED_BLOCKS = 1 # allow 0~3 +FREEZE_BLOCKS = [True, False, False, False, False] # for gluoncv backbone +USE_07_METRIC = True + +MUTILPY_BIAS_GRADIENT = None # 2.0 # if None, will not multipy +GRADIENT_CLIPPING_BY_NORM = None # 10.0 if None, will not clip + +BATCH_SIZE = 1 +EPSILON = 1e-5 +MOMENTUM = 0.9 +LR = 5e-4 * NUM_GPU * BATCH_SIZE +DECAY_STEP = [SAVE_WEIGHTS_INTE*12, SAVE_WEIGHTS_INTE*16, SAVE_WEIGHTS_INTE*20] +MAX_ITERATION = SAVE_WEIGHTS_INTE*20 +WARM_SETP = int(1.0 / 4.0 * SAVE_WEIGHTS_INTE) + +# -------------------------------------------- Data_preprocess_config +DATASET_NAME = 'pascal' # '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_ = [0.485, 0.456, 0.406] +PIXEL_STD = [0.229, 0.224, 0.225] # R, G, B. In tf, channel is RGB. In openCV, channel is BGR +IMG_SHORT_SIDE_LEN = 600 +IMG_MAX_LENGTH = 1000 +CLASS_NUM = 20 + +# --------------------------------------------- Network_config +BATCH_SIZE = 1 +SUBNETS_WEIGHTS_INITIALIZER = tf.random_normal_initializer(mean=0.0, stddev=0.01, seed=None) +SUBNETS_BIAS_INITIALIZER = tf.constant_initializer(value=0.0) +PROBABILITY = 0.01 +FINAL_CONV_BIAS_INITIALIZER = tf.constant_initializer(value=-math.log((1.0 - PROBABILITY) / PROBABILITY)) +WEIGHT_DECAY = 1e-4 + +# ---------------------------------------------Anchor config +LEVEL = ['P3', 'P4', 'P5', 'P6', 'P7'] +BASE_ANCHOR_SIZE_LIST = [32, 64, 128, 256, 512] +ANCHOR_STRIDE = [8, 16, 32, 64, 128] +ANCHOR_SCALES = [2 ** 0, 2 ** (1.0 / 3.0), 2 ** (2.0 / 3.0)] +ANCHOR_RATIOS = [0.5, 1.0, 2.0] +ANCHOR_SCALE_FACTORS = [10.0, 10.0, 5.0, 5.0] +USE_CENTER_OFFSET = True + +# --------------------------------------------RPN config +SHARE_NET = True +USE_P5 = True +IOU_POSITIVE_THRESHOLD = 0.5 +IOU_NEGATIVE_THRESHOLD = 0.4 + +NMS = True +NMS_IOU_THRESHOLD = 0.5 +MAXIMUM_DETECTIONS = 100 +FILTERED_SCORE = 0.01 +VIS_SCORE = 0.5 + + diff --git a/libs/configs/cfgs_res50_coco_1x_v1.py b/libs/configs/cfgs_res50_coco_1x_v1.py new file mode 100644 index 0000000..61d6fd5 --- /dev/null +++ b/libs/configs/cfgs_res50_coco_1x_v1.py @@ -0,0 +1,104 @@ +# -*- coding: utf-8 -*- +from __future__ import division, print_function, absolute_import +import os +import tensorflow as tf +import math + +""" +epoch-00: 00.0 epoch-01: 7.40 +epoch-02: 15.4 epoch-03: 18.8 +epoch-04: 20.7 epoch-05: 23.0 +epoch-06: 23.6 epoch-07: 25.3 +epoch-08: 24.7 epoch-09: 26.7 +epoch-11: 26.2 epoch-12: 30.7 +epoch-13: 30.8 epoch-14: 31.1 +epoch-15: 31.2 epoch-16: 31.4 +epoch-19: 31.5 + +""" + +# ------------------------------------------------ +VERSION = 'RetinaNet_COCO_1x_20190522' +NET_NAME = 'resnet_v1_50' # 'MobilenetV2' +ADD_BOX_IN_TENSORBOARD = True + +# ---------------------------------------- System_config +ROOT_PATH = os.path.abspath('../') +print(20*"++--") +print(ROOT_PATH) +GPU_GROUP = "0,1,2,3,4,5,6,7" +NUM_GPU = len(GPU_GROUP.strip().split(',')) +SHOW_TRAIN_INFO_INTE = 20 +SMRY_ITER = 200 +SAVE_WEIGHTS_INTE = 20000 * 5 + +SUMMARY_PATH = ROOT_PATH + '/output/summary' +TEST_SAVE_PATH = ROOT_PATH + '/tools/test_result' + +if NET_NAME.startswith("resnet"): + weights_name = NET_NAME +elif NET_NAME.startswith("MobilenetV2"): + weights_name = "mobilenet/mobilenet_v2_1.0_224" +else: + raise Exception('net name must in [resnet_v1_101, resnet_v1_50, MobilenetV2]') + +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/' + +# ------------------------------------------ Train config +RESTORE_FROM_RPN = False +FIXED_BLOCKS = 1 # allow 0~3 +FREEZE_BLOCKS = [True, False, False, False, False] # for gluoncv backbone +USE_07_METRIC = True + +MUTILPY_BIAS_GRADIENT = None # 2.0 # if None, will not multipy +GRADIENT_CLIPPING_BY_NORM = None # 10.0 if None, will not clip + +BATCH_SIZE = 1 +EPSILON = 1e-5 +MOMENTUM = 0.9 +LR = 5e-4 * NUM_GPU * BATCH_SIZE +DECAY_STEP = [SAVE_WEIGHTS_INTE*12, SAVE_WEIGHTS_INTE*16, SAVE_WEIGHTS_INTE*20] +MAX_ITERATION = SAVE_WEIGHTS_INTE*20 +WARM_SETP = int(1.0 / 8.0 * SAVE_WEIGHTS_INTE) + +# -------------------------------------------- Data_preprocess_config +DATASET_NAME = 'coco' # '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_ = [0.485, 0.456, 0.406] +PIXEL_STD = [0.229, 0.224, 0.225] # R, G, B. In tf, channel is RGB. In openCV, channel is BGR +IMG_SHORT_SIDE_LEN = 600 +IMG_MAX_LENGTH = 1000 +CLASS_NUM = 80 + +# --------------------------------------------- Network_config +BATCH_SIZE = 1 +SUBNETS_WEIGHTS_INITIALIZER = tf.random_normal_initializer(mean=0.0, stddev=0.01, seed=None) +SUBNETS_BIAS_INITIALIZER = tf.constant_initializer(value=0.0) +PROBABILITY = 0.01 +FINAL_CONV_BIAS_INITIALIZER = tf.constant_initializer(value=-math.log((1.0 - PROBABILITY) / PROBABILITY)) +WEIGHT_DECAY = 1e-4 + +# ---------------------------------------------Anchor config +LEVEL = ['P3', 'P4', 'P5', 'P6', 'P7'] +BASE_ANCHOR_SIZE_LIST = [32, 64, 128, 256, 512] +ANCHOR_STRIDE = [8, 16, 32, 64, 128] +ANCHOR_SCALES = [2 ** 0, 2 ** (1.0 / 3.0), 2 ** (2.0 / 3.0)] +ANCHOR_RATIOS = [0.5, 1.0, 2.0] +ANCHOR_SCALE_FACTORS = None +USE_CENTER_OFFSET = True + +# --------------------------------------------RPN config +SHARE_NET = True +USE_P5 = True +IOU_POSITIVE_THRESHOLD = 0.5 +IOU_NEGATIVE_THRESHOLD = 0.4 + +NMS = True +NMS_IOU_THRESHOLD = 0.5 +MAXIMUM_DETECTIONS = 100 +FILTERED_SCORE = 0.05 +VIS_SCORE = 0.5 + + diff --git a/libs/configs/cfgs_res50_coco_1x_v2.py b/libs/configs/cfgs_res50_coco_1x_v2.py new file mode 100644 index 0000000..cbc0284 --- /dev/null +++ b/libs/configs/cfgs_res50_coco_1x_v2.py @@ -0,0 +1,98 @@ +# -*- coding: utf-8 -*- +from __future__ import division, print_function, absolute_import +import os +import tensorflow as tf +import math + +""" +epoch-00: 00.0 epoch-01: 4.00 +epoch-02: 09.6 epoch-03: 14.6 +epoch-04: 19.6 + +""" + +# ------------------------------------------------ +VERSION = 'RetinaNet_COCO_1x_20190523' +NET_NAME = 'resnet50_v1d' # 'MobilenetV2' +ADD_BOX_IN_TENSORBOARD = True + +# ---------------------------------------- System_config +ROOT_PATH = os.path.abspath('../') +print(20*"++--") +print(ROOT_PATH) +GPU_GROUP = "0,1,2,3,4,5,6,7" +NUM_GPU = len(GPU_GROUP.strip().split(',')) +SHOW_TRAIN_INFO_INTE = 20 +SMRY_ITER = 200 +SAVE_WEIGHTS_INTE = 80000 + +SUMMARY_PATH = ROOT_PATH + '/output/summary' +TEST_SAVE_PATH = ROOT_PATH + '/tools/test_result' + +if NET_NAME.startswith("resnet"): + weights_name = NET_NAME +elif NET_NAME.startswith("MobilenetV2"): + weights_name = "mobilenet/mobilenet_v2_1.0_224" +else: + raise Exception('net name must in [resnet_v1_101, resnet_v1_50, MobilenetV2]') + +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/' + +# ------------------------------------------ Train config +RESTORE_FROM_RPN = False +FIXED_BLOCKS = 1 # allow 0~3 +FREEZE_BLOCKS = [True, False, False, False, False] # for gluoncv backbone +USE_07_METRIC = True + +MUTILPY_BIAS_GRADIENT = None # 2.0 # if None, will not multipy +GRADIENT_CLIPPING_BY_NORM = None # 10.0 if None, will not clip + +BATCH_SIZE = 1 +EPSILON = 1e-5 +MOMENTUM = 0.9 +LR = 5e-4 * NUM_GPU * BATCH_SIZE +DECAY_STEP = [SAVE_WEIGHTS_INTE*12, SAVE_WEIGHTS_INTE*16, SAVE_WEIGHTS_INTE*20] +MAX_ITERATION = SAVE_WEIGHTS_INTE*20 +WARM_SETP = int(1.0 / 8.0 * SAVE_WEIGHTS_INTE) + +# -------------------------------------------- Data_preprocess_config +DATASET_NAME = 'coco' # '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_ = [0.485, 0.456, 0.406] +PIXEL_STD = [0.229, 0.224, 0.225] # R, G, B. In tf, channel is RGB. In openCV, channel is BGR +IMG_SHORT_SIDE_LEN = 600 +IMG_MAX_LENGTH = 1000 +CLASS_NUM = 80 + +# --------------------------------------------- Network_config +BATCH_SIZE = 1 +SUBNETS_WEIGHTS_INITIALIZER = tf.random_normal_initializer(mean=0.0, stddev=0.01, seed=None) +SUBNETS_BIAS_INITIALIZER = tf.constant_initializer(value=0.0) +PROBABILITY = 0.01 +FINAL_CONV_BIAS_INITIALIZER = tf.constant_initializer(value=-math.log((1.0 - PROBABILITY) / PROBABILITY)) +WEIGHT_DECAY = 1e-4 + +# ---------------------------------------------Anchor config +LEVEL = ['P3', 'P4', 'P5', 'P6', 'P7'] +BASE_ANCHOR_SIZE_LIST = [32, 64, 128, 256, 512] +ANCHOR_STRIDE = [8, 16, 32, 64, 128] +ANCHOR_SCALES = [2 ** 0, 2 ** (1.0 / 3.0), 2 ** (2.0 / 3.0)] +ANCHOR_RATIOS = [0.5, 1.0, 2.0] +ANCHOR_SCALE_FACTORS = None +USE_CENTER_OFFSET = True + +# --------------------------------------------RPN config +SHARE_NET = True +USE_P5 = True +IOU_POSITIVE_THRESHOLD = 0.5 +IOU_NEGATIVE_THRESHOLD = 0.4 + +NMS = True +NMS_IOU_THRESHOLD = 0.5 +MAXIMUM_DETECTIONS = 100 +FILTERED_SCORE = 0.05 +VIS_SCORE = 0.5 + + diff --git a/libs/configs/cfgs_res50_coco_1x_v3.py b/libs/configs/cfgs_res50_coco_1x_v3.py new file mode 100644 index 0000000..2157886 --- /dev/null +++ b/libs/configs/cfgs_res50_coco_1x_v3.py @@ -0,0 +1,97 @@ +# -*- coding: utf-8 -*- +from __future__ import division, print_function, absolute_import +import os +import tensorflow as tf +import math + +""" +epoch-00: 00.0 epoch-01: 2.60 +epoch-01: 06.4 epoch-02: 12.8 + +""" + +# ------------------------------------------------ +VERSION = 'RetinaNet_COCO_1x_20190524' +NET_NAME = 'resnet50_v1d' # 'MobilenetV2' +ADD_BOX_IN_TENSORBOARD = True + +# ---------------------------------------- System_config +ROOT_PATH = os.path.abspath('../') +print(20*"++--") +print(ROOT_PATH) +GPU_GROUP = "0,1,2,3,4,5,6,7" +NUM_GPU = len(GPU_GROUP.strip().split(',')) +SHOW_TRAIN_INFO_INTE = 20 +SMRY_ITER = 200 +SAVE_WEIGHTS_INTE = 80000 + +SUMMARY_PATH = ROOT_PATH + '/output/summary' +TEST_SAVE_PATH = ROOT_PATH + '/tools/test_result' + +if NET_NAME.startswith("resnet"): + weights_name = NET_NAME +elif NET_NAME.startswith("MobilenetV2"): + weights_name = "mobilenet/mobilenet_v2_1.0_224" +else: + raise Exception('net name must in [resnet_v1_101, resnet_v1_50, MobilenetV2]') + +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/' + +# ------------------------------------------ Train config +RESTORE_FROM_RPN = False +FIXED_BLOCKS = 1 # allow 0~3 +FREEZE_BLOCKS = [True, False, False, False, False] # for gluoncv backbone +USE_07_METRIC = True + +MUTILPY_BIAS_GRADIENT = None # 2.0 # if None, will not multipy +GRADIENT_CLIPPING_BY_NORM = None # 10.0 if None, will not clip + +BATCH_SIZE = 1 +EPSILON = 1e-5 +MOMENTUM = 0.9 +LR = 5e-4 * NUM_GPU * BATCH_SIZE +DECAY_STEP = [SAVE_WEIGHTS_INTE*12, SAVE_WEIGHTS_INTE*16, SAVE_WEIGHTS_INTE*20] +MAX_ITERATION = SAVE_WEIGHTS_INTE*20 +WARM_SETP = int(1.0 / 4.0 * SAVE_WEIGHTS_INTE) + +# -------------------------------------------- Data_preprocess_config +DATASET_NAME = 'coco' # '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_ = [0.485, 0.456, 0.406] +PIXEL_STD = [0.229, 0.224, 0.225] # R, G, B. In tf, channel is RGB. In openCV, channel is BGR +IMG_SHORT_SIDE_LEN = 600 +IMG_MAX_LENGTH = 1000 +CLASS_NUM = 80 + +# --------------------------------------------- Network_config +BATCH_SIZE = 1 +SUBNETS_WEIGHTS_INITIALIZER = tf.random_normal_initializer(mean=0.0, stddev=0.01, seed=None) +SUBNETS_BIAS_INITIALIZER = tf.constant_initializer(value=0.0) +PROBABILITY = 0.01 +FINAL_CONV_BIAS_INITIALIZER = tf.constant_initializer(value=-math.log((1.0 - PROBABILITY) / PROBABILITY)) +WEIGHT_DECAY = 1e-4 + +# ---------------------------------------------Anchor config +LEVEL = ['P3', 'P4', 'P5', 'P6', 'P7'] +BASE_ANCHOR_SIZE_LIST = [32, 64, 128, 256, 512] +ANCHOR_STRIDE = [8, 16, 32, 64, 128] +ANCHOR_SCALES = [2 ** 0, 2 ** (1.0 / 3.0), 2 ** (2.0 / 3.0)] +ANCHOR_RATIOS = [0.5, 1.0, 2.0] +ANCHOR_SCALE_FACTORS = [10.0, 10.0, 5.0, 5.0] +USE_CENTER_OFFSET = True + +# --------------------------------------------RPN config +SHARE_NET = True +USE_P5 = True +IOU_POSITIVE_THRESHOLD = 0.5 +IOU_NEGATIVE_THRESHOLD = 0.4 + +NMS = True +NMS_IOU_THRESHOLD = 0.5 +MAXIMUM_DETECTIONS = 100 +FILTERED_SCORE = 0.05 +VIS_SCORE = 0.5 + + diff --git a/libs/configs/cfgs_res50_voc0712_v1.py b/libs/configs/cfgs_res50_voc0712_v1.py new file mode 100644 index 0000000..deb7f6e --- /dev/null +++ b/libs/configs/cfgs_res50_voc0712_v1.py @@ -0,0 +1,115 @@ +# -*- coding: utf-8 -*- +from __future__ import division, print_function, absolute_import +import os +import tensorflow as tf +import math + +""" +cls : boat|| Recall: 0.9505703422053232 || Precison: 0.005342907824154218|| AP: 0.7096663579871666 +cls : horse|| Recall: 0.9971264367816092 || Precison: 0.010271438297368499|| AP: 0.8762579915407834 +cls : cat|| Recall: 0.9832402234636871 || Precison: 0.012731941982855283|| AP: 0.8657648932693558 +cls : bottle|| Recall: 0.9147121535181236 || Precison: 0.00529309430097842|| AP: 0.6864996193318956 +cls : pottedplant|| Recall: 0.925 || Precison: 0.005485341536636892|| AP: 0.5534334829931036 +cls : bus|| Recall: 0.9953051643192489 || Precison: 0.006379009448155504|| AP: 0.8598362716395636 +cls : car|| Recall: 0.9891756869275604 || Precison: 0.01537724736917043|| AP: 0.8843564429054561 +cls : aeroplane|| Recall: 0.9543859649122807 || Precison: 0.014160029153001198|| AP: 0.8542149220907074 +cls : bicycle|| Recall: 0.9881305637982196 || Precison: 0.00675963705011875|| AP: 0.8498077362487978 +cls : cow|| Recall: 0.9918032786885246 || Precison: 0.009082720312265426|| AP: 0.8451994158806354 +cls : dog|| Recall: 0.9979550102249489 || Precison: 0.01499231950844854|| AP: 0.8590428896283084 +cls : motorbike|| Recall: 0.9938461538461538 || Precison: 0.006394773312215403|| AP: 0.8564424864150487 +cls : bird|| Recall: 0.9455337690631809 || Precison: 0.017192885156280948|| AP: 0.7948506002769691 +cls : tvmonitor|| Recall: 0.9512987012987013 || Precison: 0.00638038412961108|| AP: 0.7842655696224038 +cls : chair|| Recall: 0.9629629629629629 || Precison: 0.006125780447989768|| AP: 0.6172742830134138 +cls : sheep|| Recall: 0.987603305785124 || Precison: 0.007774886141834743|| AP: 0.8365473938440467 +cls : diningtable|| Recall: 0.9805825242718447 || Precison: 0.001985121416708433|| AP: 0.7371673843361081 +cls : train|| Recall: 0.9468085106382979 || Precison: 0.011325076348829318|| AP: 0.8543968318356752 +cls : person|| Recall: 0.9867491166077739 || Precison: 0.027760691407730496|| AP: 0.8422619773565775 +cls : sofa|| Recall: 0.9874476987447699 || Precison: 0.0038979271616153273|| AP: 0.7647898552993955 +mAP is : 0.7966038202757706 (coco_463120model.ckpt) +""" + +# ------------------------------------------------ +VERSION = 'RetinaNet_VOC0712_20190523' +NET_NAME = 'resnet50_v1d' # 'MobilenetV2' +ADD_BOX_IN_TENSORBOARD = True + +# ---------------------------------------- System_config +ROOT_PATH = os.path.abspath('../') +print(20*"++--") +print(ROOT_PATH) +GPU_GROUP = "0,1,2,3,4,5,6,7" +NUM_GPU = len(GPU_GROUP.strip().split(',')) +SHOW_TRAIN_INFO_INTE = 10 +SMRY_ITER = 100 +SAVE_WEIGHTS_INTE = (11540 + 5000) * 2 + +SUMMARY_PATH = ROOT_PATH + '/output/summary' +TEST_SAVE_PATH = ROOT_PATH + '/tools/test_result' + +if NET_NAME.startswith("resnet"): + weights_name = NET_NAME +elif NET_NAME.startswith("MobilenetV2"): + weights_name = "mobilenet/mobilenet_v2_1.0_224" +else: + raise Exception('net name must in [resnet_v1_101, resnet_v1_50, MobilenetV2]') + +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/' + +# ------------------------------------------ Train config +RESTORE_FROM_RPN = False +FIXED_BLOCKS = 1 # allow 0~3 +FREEZE_BLOCKS = [True, False, False, False, False] # for gluoncv backbone +USE_07_METRIC = True + +MUTILPY_BIAS_GRADIENT = None # 2.0 # if None, will not multipy +GRADIENT_CLIPPING_BY_NORM = None # 10.0 if None, will not clip + +BATCH_SIZE = 1 +EPSILON = 1e-5 +MOMENTUM = 0.9 +LR = 5e-4 * NUM_GPU * BATCH_SIZE +DECAY_STEP = [SAVE_WEIGHTS_INTE*12, SAVE_WEIGHTS_INTE*16, SAVE_WEIGHTS_INTE*20] +MAX_ITERATION = SAVE_WEIGHTS_INTE*20 +WARM_SETP = int(1.0 / 4.0 * SAVE_WEIGHTS_INTE) + +# -------------------------------------------- Data_preprocess_config +DATASET_NAME = 'pascal' # '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_ = [0.485, 0.456, 0.406] +PIXEL_STD = [0.229, 0.224, 0.225] # R, G, B. In tf, channel is RGB. In openCV, channel is BGR +IMG_SHORT_SIDE_LEN = 600 +IMG_MAX_LENGTH = 1000 +CLASS_NUM = 20 + +# --------------------------------------------- Network_config +BATCH_SIZE = 1 +SUBNETS_WEIGHTS_INITIALIZER = tf.random_normal_initializer(mean=0.0, stddev=0.01, seed=None) +SUBNETS_BIAS_INITIALIZER = tf.constant_initializer(value=0.0) +PROBABILITY = 0.01 +FINAL_CONV_BIAS_INITIALIZER = tf.constant_initializer(value=-math.log((1.0 - PROBABILITY) / PROBABILITY)) +WEIGHT_DECAY = 1e-4 + +# ---------------------------------------------Anchor config +LEVEL = ['P3', 'P4', 'P5', 'P6', 'P7'] +BASE_ANCHOR_SIZE_LIST = [32, 64, 128, 256, 512] +ANCHOR_STRIDE = [8, 16, 32, 64, 128] +ANCHOR_SCALES = [2 ** 0, 2 ** (1.0 / 3.0), 2 ** (2.0 / 3.0)] +ANCHOR_RATIOS = [0.5, 1.0, 2.0] +ANCHOR_SCALE_FACTORS = [10.0, 10.0, 5.0, 5.0] +USE_CENTER_OFFSET = True + +# --------------------------------------------RPN config +SHARE_NET = True +USE_P5 = True +IOU_POSITIVE_THRESHOLD = 0.5 +IOU_NEGATIVE_THRESHOLD = 0.4 + +NMS = True +NMS_IOU_THRESHOLD = 0.5 +MAXIMUM_DETECTIONS = 100 +FILTERED_SCORE = 0.01 +VIS_SCORE = 0.5 + + diff --git a/libs/configs/cfgs_res50_voc0712_v2.py b/libs/configs/cfgs_res50_voc0712_v2.py new file mode 100644 index 0000000..c7f817e --- /dev/null +++ b/libs/configs/cfgs_res50_voc0712_v2.py @@ -0,0 +1,116 @@ +# -*- coding: utf-8 -*- +from __future__ import division, print_function, absolute_import +import os +import tensorflow as tf +import math + +""" +cls : train|| Recall: 0.9574468085106383 || Precison: 0.011264550043806583|| AP: 0.8429614751356598 +cls : boat|| Recall: 0.9619771863117871 || Precison: 0.005608636857389878|| AP: 0.7247602142711771 +cls : motorbike|| Recall: 0.9938461538461538 || Precison: 0.00780136705069681|| AP: 0.8620336717055882 +cls : aeroplane|| Recall: 0.968421052631579 || Precison: 0.015942698706099816|| AP: 0.877200533188366 +cls : person|| Recall: 0.9882950530035336 || Precison: 0.031197060853440043|| AP: 0.8549563913368059 +cls : pottedplant|| Recall: 0.9145833333333333 || Precison: 0.006810847710065781|| AP: 0.5597989508143375 +cls : sofa|| Recall: 0.99581589958159 || Precison: 0.004477303083319224|| AP: 0.7809330043853933 +cls : car|| Recall: 0.9900083263946711 || Precison: 0.015191781872077275|| AP: 0.8929651092188676 +cls : cat|| Recall: 0.994413407821229 || Precison: 0.0132925098947054|| AP: 0.8900856486739736 +cls : horse|| Recall: 0.9913793103448276 || Precison: 0.009228793836770725|| AP: 0.8822391183389151 +cls : tvmonitor|| Recall: 0.961038961038961 || Precison: 0.006890771952695782|| AP: 0.7956874756219561 +cls : sheep|| Recall: 0.9834710743801653 || Precison: 0.008470956719817768|| AP: 0.847823073416635 +cls : dog|| Recall: 0.9959100204498977 || Precison: 0.0186640095044648|| AP: 0.8711714077751838 +cls : bus|| Recall: 0.9859154929577465 || Precison: 0.006062180652983459|| AP: 0.8646568186454162 +cls : chair|| Recall: 0.9708994708994709 || Precison: 0.007137300661221315|| AP: 0.6544968051248526 +cls : bicycle|| Recall: 0.9881305637982196 || Precison: 0.00703704486380254|| AP: 0.8543458412723929 +cls : bird|| Recall: 0.9760348583877996 || Precison: 0.016314639475600873|| AP: 0.8255116265985485 +cls : diningtable|| Recall: 0.9854368932038835 || Precison: 0.0024620086594787332|| AP: 0.7423151271987897 +cls : bottle|| Recall: 0.9381663113006397 || Precison: 0.0067838421214924454|| AP: 0.7201777267756303 +cls : cow|| Recall: 0.9959016393442623 || Precison: 0.00847162181006833|| AP: 0.8656722996831789 +mAP is : 0.8104896159590833 (pascal_430040model.ckpt) + +""" + +# ------------------------------------------------ +VERSION = 'RetinaNet_VOC0712_20190524' +NET_NAME = 'resnet101_v1d' # 'MobilenetV2' +ADD_BOX_IN_TENSORBOARD = True + +# ---------------------------------------- System_config +ROOT_PATH = os.path.abspath('../') +print(20*"++--") +print(ROOT_PATH) +GPU_GROUP = "0,1,2,3,4,5,6,7" +NUM_GPU = len(GPU_GROUP.strip().split(',')) +SHOW_TRAIN_INFO_INTE = 10 +SMRY_ITER = 100 +SAVE_WEIGHTS_INTE = (11540 + 5000) * 2 + +SUMMARY_PATH = ROOT_PATH + '/output/summary' +TEST_SAVE_PATH = ROOT_PATH + '/tools/test_result' + +if NET_NAME.startswith("resnet"): + weights_name = NET_NAME +elif NET_NAME.startswith("MobilenetV2"): + weights_name = "mobilenet/mobilenet_v2_1.0_224" +else: + raise Exception('net name must in [resnet_v1_101, resnet_v1_50, MobilenetV2]') + +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/' + +# ------------------------------------------ Train config +RESTORE_FROM_RPN = False +FIXED_BLOCKS = 1 # allow 0~3 +FREEZE_BLOCKS = [True, False, False, False, False] # for gluoncv backbone +USE_07_METRIC = True + +MUTILPY_BIAS_GRADIENT = None # 2.0 # if None, will not multipy +GRADIENT_CLIPPING_BY_NORM = None # 10.0 if None, will not clip + +BATCH_SIZE = 1 +EPSILON = 1e-5 +MOMENTUM = 0.9 +LR = 5e-4 * NUM_GPU * BATCH_SIZE +DECAY_STEP = [SAVE_WEIGHTS_INTE*12, SAVE_WEIGHTS_INTE*16, SAVE_WEIGHTS_INTE*20] +MAX_ITERATION = SAVE_WEIGHTS_INTE*20 +WARM_SETP = int(1.0 / 4.0 * SAVE_WEIGHTS_INTE) + +# -------------------------------------------- Data_preprocess_config +DATASET_NAME = 'pascal' # '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_ = [0.485, 0.456, 0.406] +PIXEL_STD = [0.229, 0.224, 0.225] # R, G, B. In tf, channel is RGB. In openCV, channel is BGR +IMG_SHORT_SIDE_LEN = 600 +IMG_MAX_LENGTH = 1000 +CLASS_NUM = 20 + +# --------------------------------------------- Network_config +BATCH_SIZE = 1 +SUBNETS_WEIGHTS_INITIALIZER = tf.random_normal_initializer(mean=0.0, stddev=0.01, seed=None) +SUBNETS_BIAS_INITIALIZER = tf.constant_initializer(value=0.0) +PROBABILITY = 0.01 +FINAL_CONV_BIAS_INITIALIZER = tf.constant_initializer(value=-math.log((1.0 - PROBABILITY) / PROBABILITY)) +WEIGHT_DECAY = 1e-4 + +# ---------------------------------------------Anchor config +LEVEL = ['P3', 'P4', 'P5', 'P6', 'P7'] +BASE_ANCHOR_SIZE_LIST = [32, 64, 128, 256, 512] +ANCHOR_STRIDE = [8, 16, 32, 64, 128] +ANCHOR_SCALES = [2 ** 0, 2 ** (1.0 / 3.0), 2 ** (2.0 / 3.0)] +ANCHOR_RATIOS = [0.5, 1.0, 2.0] +ANCHOR_SCALE_FACTORS = [10.0, 10.0, 5.0, 5.0] +USE_CENTER_OFFSET = True + +# --------------------------------------------RPN config +SHARE_NET = True +USE_P5 = True +IOU_POSITIVE_THRESHOLD = 0.5 +IOU_NEGATIVE_THRESHOLD = 0.4 + +NMS = True +NMS_IOU_THRESHOLD = 0.5 +MAXIMUM_DETECTIONS = 100 +FILTERED_SCORE = 0.01 +VIS_SCORE = 0.5 + + diff --git a/libs/configs/cfgs_res50_voc0712_v3.py b/libs/configs/cfgs_res50_voc0712_v3.py new file mode 100644 index 0000000..0bfb2ae --- /dev/null +++ b/libs/configs/cfgs_res50_voc0712_v3.py @@ -0,0 +1,116 @@ +# -*- coding: utf-8 -*- +from __future__ import division, print_function, absolute_import +import os +import tensorflow as tf +import math + +""" +cls : boat|| Recall: 0.9695817490494296 || Precison: 0.004761726919629519|| AP: 0.7281771379381616 +cls : bicycle|| Recall: 0.9881305637982196 || Precison: 0.006502382254159182|| AP: 0.8489062261958693 +cls : pottedplant|| Recall: 0.9395833333333333 || Precison: 0.005247664149494432|| AP: 0.5544772267130251 +cls : tvmonitor|| Recall: 0.961038961038961 || Precison: 0.005156255443681845|| AP: 0.8054443156582788 +cls : motorbike|| Recall: 0.9938461538461538 || Precison: 0.006123338831067887|| AP: 0.8633424176495925 +cls : horse|| Recall: 0.9942528735632183 || Precison: 0.009731949483869153|| AP: 0.8800299351210068 +cls : car|| Recall: 0.9933388842631141 || Precison: 0.013872415637572967|| AP: 0.8903760611050385 +cls : person|| Recall: 0.9860865724381626 || Precison: 0.02783284088217327|| AP: 0.8557435827115095 +cls : aeroplane|| Recall: 0.9859649122807017 || Precison: 0.011732286752118909|| AP: 0.8786021097248355 +cls : train|| Recall: 0.9680851063829787 || Precison: 0.010527939531834484|| AP: 0.830439540076824 +cls : sofa|| Recall: 1.0 || Precison: 0.0033251248660906827|| AP: 0.7736534869486386 +cls : sheep|| Recall: 0.9917355371900827 || Precison: 0.006887447626700339|| AP: 0.8304997616000941 +cls : dog|| Recall: 0.9938650306748467 || Precison: 0.012805311833056676|| AP: 0.8685913031298029 +cls : bottle|| Recall: 0.9381663113006397 || Precison: 0.006485657852068041|| AP: 0.7242882524763133 +cls : bus|| Recall: 0.9906103286384976 || Precison: 0.005803718780943998|| AP: 0.8669273157836549 +cls : cow|| Recall: 0.9877049180327869 || Precison: 0.0075783780384264645|| AP: 0.8606713765311622 +cls : bird|| Recall: 0.9738562091503268 || Precison: 0.011930817274328724|| AP: 0.8311803084919606 +cls : diningtable|| Recall: 0.970873786407767 || Precison: 0.0017596959245442388|| AP: 0.730199218623714 +cls : cat|| Recall: 0.9888268156424581 || Precison: 0.010336370007007708|| AP: 0.8831441748779935 +cls : chair|| Recall: 0.9708994708994709 || Precison: 0.005643332180063815|| AP: 0.6334387740339388 +mAP is : 0.8069066262695707 (pascal_430040model.ckpt) + +""" + +# ------------------------------------------------ +VERSION = 'RetinaNet_VOC0712_20190525' +NET_NAME = 'resnet101_v1d' # 'MobilenetV2' +ADD_BOX_IN_TENSORBOARD = True + +# ---------------------------------------- System_config +ROOT_PATH = os.path.abspath('../') +print(20*"++--") +print(ROOT_PATH) +GPU_GROUP = "0,1,2,3,4,5,6,7" +NUM_GPU = len(GPU_GROUP.strip().split(',')) +SHOW_TRAIN_INFO_INTE = 10 +SMRY_ITER = 100 +SAVE_WEIGHTS_INTE = (11540 + 5000) * 2 + +SUMMARY_PATH = ROOT_PATH + '/output/summary' +TEST_SAVE_PATH = ROOT_PATH + '/tools/test_result' + +if NET_NAME.startswith("resnet"): + weights_name = NET_NAME +elif NET_NAME.startswith("MobilenetV2"): + weights_name = "mobilenet/mobilenet_v2_1.0_224" +else: + raise Exception('net name must in [resnet_v1_101, resnet_v1_50, MobilenetV2]') + +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/' + +# ------------------------------------------ Train config +RESTORE_FROM_RPN = False +FIXED_BLOCKS = 1 # allow 0~3 +FREEZE_BLOCKS = [True, False, False, False, False] # for gluoncv backbone +USE_07_METRIC = True + +MUTILPY_BIAS_GRADIENT = None # 2.0 # if None, will not multipy +GRADIENT_CLIPPING_BY_NORM = None # 10.0 if None, will not clip + +BATCH_SIZE = 1 +EPSILON = 1e-5 +MOMENTUM = 0.9 +LR = 5e-4 * NUM_GPU * BATCH_SIZE +DECAY_STEP = [SAVE_WEIGHTS_INTE*12, SAVE_WEIGHTS_INTE*16, SAVE_WEIGHTS_INTE*20] +MAX_ITERATION = SAVE_WEIGHTS_INTE*20 +WARM_SETP = int(1.0 / 4.0 * SAVE_WEIGHTS_INTE) + +# -------------------------------------------- Data_preprocess_config +DATASET_NAME = 'pascal' # '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_ = [0.485, 0.456, 0.406] +PIXEL_STD = [0.229, 0.224, 0.225] # R, G, B. In tf, channel is RGB. In openCV, channel is BGR +IMG_SHORT_SIDE_LEN = 800 +IMG_MAX_LENGTH = 1333 +CLASS_NUM = 20 + +# --------------------------------------------- Network_config +BATCH_SIZE = 1 +SUBNETS_WEIGHTS_INITIALIZER = tf.random_normal_initializer(mean=0.0, stddev=0.01, seed=None) +SUBNETS_BIAS_INITIALIZER = tf.constant_initializer(value=0.0) +PROBABILITY = 0.01 +FINAL_CONV_BIAS_INITIALIZER = tf.constant_initializer(value=-math.log((1.0 - PROBABILITY) / PROBABILITY)) +WEIGHT_DECAY = 1e-4 + +# ---------------------------------------------Anchor config +LEVEL = ['P3', 'P4', 'P5', 'P6', 'P7'] +BASE_ANCHOR_SIZE_LIST = [32, 64, 128, 256, 512] +ANCHOR_STRIDE = [8, 16, 32, 64, 128] +ANCHOR_SCALES = [2 ** 0, 2 ** (1.0 / 3.0), 2 ** (2.0 / 3.0)] +ANCHOR_RATIOS = [0.5, 1.0, 2.0] +ANCHOR_SCALE_FACTORS = [10.0, 10.0, 5.0, 5.0] +USE_CENTER_OFFSET = True + +# --------------------------------------------RPN config +SHARE_NET = True +USE_P5 = True +IOU_POSITIVE_THRESHOLD = 0.5 +IOU_NEGATIVE_THRESHOLD = 0.4 + +NMS = True +NMS_IOU_THRESHOLD = 0.5 +MAXIMUM_DETECTIONS = 100 +FILTERED_SCORE = 0.01 +VIS_SCORE = 0.5 + + diff --git a/libs/configs/cfgs_res50_voc07_v1.py b/libs/configs/cfgs_res50_voc07_v1.py new file mode 100644 index 0000000..85750f8 --- /dev/null +++ b/libs/configs/cfgs_res50_voc07_v1.py @@ -0,0 +1,115 @@ +# -*- coding: utf-8 -*- +from __future__ import division, print_function, absolute_import +import os +import tensorflow as tf +import math + +""" +cls : aeroplane|| Recall: 0.9263157894736842 || Precison: 0.03303303303303303|| AP: 0.784830711465123 +cls : cat|| Recall: 0.9832402234636871 || Precison: 0.024157573261958686|| AP: 0.850236615704726 +cls : person|| Recall: 0.9750441696113075 || Precison: 0.02212888383213124|| AP: 0.810026599570606 +cls : boat|| Recall: 0.9429657794676806 || Precison: 0.008830022075055188|| AP: 0.5809657874405858 +cls : tvmonitor|| Recall: 0.9383116883116883 || Precison: 0.008098187014879368|| AP: 0.7375754411267105 +cls : cow|| Recall: 0.9836065573770492 || Precison: 0.011059398184415465|| AP: 0.7811246236306398 +cls : diningtable|| Recall: 0.970873786407767 || Precison: 0.0016768957306234698|| AP: 0.6460893690943793 +cls : bottle|| Recall: 0.8763326226012793 || Precison: 0.005528577770005784|| AP: 0.5819266031025552 +cls : sofa|| Recall: 0.9874476987447699 || Precison: 0.003152888366376316|| AP: 0.6819754644795543 +cls : motorbike|| Recall: 0.9907692307692307 || Precison: 0.007024432809773124|| AP: 0.7992360964706795 +cls : sheep|| Recall: 0.9834710743801653 || Precison: 0.015635264748390488|| AP: 0.7077056201470088 +cls : bird|| Recall: 0.9520697167755992 || Precison: 0.023698481561822127|| AP: 0.7697731877317816 +cls : bus|| Recall: 0.9577464788732394 || Precison: 0.005901411710252257|| AP: 0.7751698924057402 +cls : pottedplant|| Recall: 0.86875 || Precison: 0.006732756393696719|| AP: 0.4587773532876927 +cls : dog|| Recall: 0.9959100204498977 || Precison: 0.020203277328355113|| AP: 0.8272196688960622 +cls : train|| Recall: 0.9184397163120568 || Precison: 0.013024238157497738|| AP: 0.7859268074059661 +cls : horse|| Recall: 0.9798850574712644 || Precison: 0.010243624019946529|| AP: 0.8180135223615187 +cls : car|| Recall: 0.9783513738551207 || Precison: 0.01963175833723184|| AP: 0.843137188974707 +cls : chair|| Recall: 0.9484126984126984 || Precison: 0.005720120944258738|| AP: 0.5283113983671771 +cls : bicycle|| Recall: 0.9762611275964391 || Precison: 0.008112439896436938|| AP: 0.7976561577200354 +mAP is : 0.7282839054691624 +""" + +# ------------------------------------------------ +VERSION = 'RetinaNet_20190521' +NET_NAME = 'resnet_v1_50' # 'MobilenetV2' +ADD_BOX_IN_TENSORBOARD = True + +# ---------------------------------------- System_config +ROOT_PATH = os.path.abspath('../') +print(20*"++--") +print(ROOT_PATH) +GPU_GROUP = "0,1,2,3,4,5,6,7" +NUM_GPU = len(GPU_GROUP.strip().split(',')) +SHOW_TRAIN_INFO_INTE = 10 +SMRY_ITER = 100 +SAVE_WEIGHTS_INTE = 5000 * 2 + +SUMMARY_PATH = ROOT_PATH + '/output/summary' +TEST_SAVE_PATH = ROOT_PATH + '/tools/test_result' + +if NET_NAME.startswith("resnet"): + weights_name = NET_NAME +elif NET_NAME.startswith("MobilenetV2"): + weights_name = "mobilenet/mobilenet_v2_1.0_224" +else: + raise Exception('net name must in [resnet_v1_101, resnet_v1_50, MobilenetV2]') + +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/' + +# ------------------------------------------ Train config +RESTORE_FROM_RPN = False +FIXED_BLOCKS = 1 # allow 0~3 +FREEZE_BLOCKS = [True, False, False, False, False] # for gluoncv backbone +USE_07_METRIC = True + +MUTILPY_BIAS_GRADIENT = None # 2.0 # if None, will not multipy +GRADIENT_CLIPPING_BY_NORM = None # 10.0 if None, will not clip + +BATCH_SIZE = 1 +EPSILON = 1e-5 +MOMENTUM = 0.9 +LR = 5e-4 * NUM_GPU * BATCH_SIZE +DECAY_STEP = [SAVE_WEIGHTS_INTE*12, SAVE_WEIGHTS_INTE*16, SAVE_WEIGHTS_INTE*20] +MAX_ITERATION = SAVE_WEIGHTS_INTE*20 +WARM_SETP = int(1.0 / 8.0 * SAVE_WEIGHTS_INTE) + +# -------------------------------------------- Data_preprocess_config +DATASET_NAME = 'pascal' # '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_ = [0.485, 0.456, 0.406] +PIXEL_STD = [0.229, 0.224, 0.225] # R, G, B. In tf, channel is RGB. In openCV, channel is BGR +IMG_SHORT_SIDE_LEN = 600 +IMG_MAX_LENGTH = 1000 +CLASS_NUM = 20 + +# --------------------------------------------- Network_config +BATCH_SIZE = 1 +SUBNETS_WEIGHTS_INITIALIZER = tf.random_normal_initializer(mean=0.0, stddev=0.01, seed=None) +SUBNETS_BIAS_INITIALIZER = tf.constant_initializer(value=0.0) +PROBABILITY = 0.01 +FINAL_CONV_BIAS_INITIALIZER = tf.constant_initializer(value=-math.log((1.0 - PROBABILITY) / PROBABILITY)) +WEIGHT_DECAY = 1e-4 + +# ---------------------------------------------Anchor config +LEVEL = ['P3', 'P4', 'P5', 'P6', 'P7'] +BASE_ANCHOR_SIZE_LIST = [32, 64, 128, 256, 512] +ANCHOR_STRIDE = [8, 16, 32, 64, 128] +ANCHOR_SCALES = [2 ** 0, 2 ** (1.0 / 3.0), 2 ** (2.0 / 3.0)] +ANCHOR_RATIOS = [0.5, 1.0, 2.0] +ANCHOR_SCALE_FACTORS = None +USE_CENTER_OFFSET = True + +# --------------------------------------------RPN config +SHARE_NET = True +USE_P5 = False +IOU_POSITIVE_THRESHOLD = 0.5 +IOU_NEGATIVE_THRESHOLD = 0.4 + +NMS = True +NMS_IOU_THRESHOLD = 0.5 +MAXIMUM_DETECTIONS = 100 +FILTERED_SCORE = 0.01 +VIS_SCORE = 0.5 + + diff --git a/libs/configs/cfgs_res50_voc07_v2.py b/libs/configs/cfgs_res50_voc07_v2.py new file mode 100644 index 0000000..f096704 --- /dev/null +++ b/libs/configs/cfgs_res50_voc07_v2.py @@ -0,0 +1,115 @@ +# -*- coding: utf-8 -*- +from __future__ import division, print_function, absolute_import +import os +import tensorflow as tf +import math + +""" +cls : aeroplane|| Recall: 0.9438596491228071 || Precison: 0.03152836380684482|| AP: 0.7773597235133686 +cls : person|| Recall: 0.9754858657243817 || Precison: 0.021128815456515397|| AP: 0.8110363404804426 +cls : sofa|| Recall: 0.9916317991631799 || Precison: 0.003753563509661071|| AP: 0.6926241276381035 +cls : car|| Recall: 0.980849292256453 || Precison: 0.016935994019207545|| AP: 0.8612891545940344 +cls : motorbike|| Recall: 0.9876923076923076 || Precison: 0.008316708552478172|| AP: 0.7979344387167545 +cls : sheep|| Recall: 0.9752066115702479 || Precison: 0.01267318225754484|| AP: 0.6992188982186315 +cls : horse|| Recall: 0.9798850574712644 || Precison: 0.010116893134753457|| AP: 0.8387371790700674 +cls : train|| Recall: 0.9326241134751773 || Precison: 0.01885980638221585|| AP: 0.7910990164518434 +cls : pottedplant|| Recall: 0.9020833333333333 || Precison: 0.0065086355915643275|| AP: 0.4667916780665033 +cls : bus|| Recall: 0.9906103286384976 || Precison: 0.005389252145484267|| AP: 0.8013951733234702 +cls : diningtable|| Recall: 0.9757281553398058 || Precison: 0.001669157947184853|| AP: 0.6493900213188186 +cls : tvmonitor|| Recall: 0.9642857142857143 || Precison: 0.00617386604581549|| AP: 0.7361445157222517 +cls : cat|| Recall: 0.9776536312849162 || Precison: 0.016213461805716402|| AP: 0.8708244700458685 +cls : bottle|| Recall: 0.8976545842217484 || Precison: 0.004023394942563887|| AP: 0.5570627230945586 +cls : cow|| Recall: 0.9877049180327869 || Precison: 0.009388025398309376|| AP: 0.7709867256180059 +cls : bird|| Recall: 0.954248366013072 || Precison: 0.01937024588713957|| AP: 0.7632915804610957 +cls : boat|| Recall: 0.9163498098859315 || Precison: 0.005341193679218102|| AP: 0.5818730701325913 +cls : dog|| Recall: 0.9938650306748467 || Precison: 0.020776333789329686|| AP: 0.8264152853325744 +cls : chair|| Recall: 0.9563492063492064 || Precison: 0.005576079160271786|| AP: 0.5278822308428679 +cls : bicycle|| Recall: 0.9762611275964391 || Precison: 0.007213646728644098|| AP: 0.811791972130752 +mAP is : 0.7316574162386302 +""" + +# ------------------------------------------------ +VERSION = 'RetinaNet_20190522' +NET_NAME = 'resnet_v1_50' # 'MobilenetV2' +ADD_BOX_IN_TENSORBOARD = True + +# ---------------------------------------- System_config +ROOT_PATH = os.path.abspath('../') +print(20*"++--") +print(ROOT_PATH) +GPU_GROUP = "0,1,2,3,4,5,6,7" +NUM_GPU = len(GPU_GROUP.strip().split(',')) +SHOW_TRAIN_INFO_INTE = 10 +SMRY_ITER = 100 +SAVE_WEIGHTS_INTE = 5000 * 2 + +SUMMARY_PATH = ROOT_PATH + '/output/summary' +TEST_SAVE_PATH = ROOT_PATH + '/tools/test_result' + +if NET_NAME.startswith("resnet"): + weights_name = NET_NAME +elif NET_NAME.startswith("MobilenetV2"): + weights_name = "mobilenet/mobilenet_v2_1.0_224" +else: + raise Exception('net name must in [resnet_v1_101, resnet_v1_50, MobilenetV2]') + +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/' + +# ------------------------------------------ Train config +RESTORE_FROM_RPN = False +FIXED_BLOCKS = 1 # allow 0~3 +FREEZE_BLOCKS = [True, False, False, False, False] # for gluoncv backbone +USE_07_METRIC = True + +MUTILPY_BIAS_GRADIENT = None # 2.0 # if None, will not multipy +GRADIENT_CLIPPING_BY_NORM = None # 10.0 if None, will not clip + +BATCH_SIZE = 1 +EPSILON = 1e-5 +MOMENTUM = 0.9 +LR = 5e-4 * NUM_GPU * BATCH_SIZE +DECAY_STEP = [SAVE_WEIGHTS_INTE*12, SAVE_WEIGHTS_INTE*16, SAVE_WEIGHTS_INTE*20] +MAX_ITERATION = SAVE_WEIGHTS_INTE*20 +WARM_SETP = int(1.0 / 8.0 * SAVE_WEIGHTS_INTE) + +# -------------------------------------------- Data_preprocess_config +DATASET_NAME = 'pascal' # '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_ = [0.485, 0.456, 0.406] +PIXEL_STD = [0.229, 0.224, 0.225] # R, G, B. In tf, channel is RGB. In openCV, channel is BGR +IMG_SHORT_SIDE_LEN = 600 +IMG_MAX_LENGTH = 1000 +CLASS_NUM = 20 + +# --------------------------------------------- Network_config +BATCH_SIZE = 1 +SUBNETS_WEIGHTS_INITIALIZER = tf.random_normal_initializer(mean=0.0, stddev=0.01, seed=None) +SUBNETS_BIAS_INITIALIZER = tf.constant_initializer(value=0.0) +PROBABILITY = 0.01 +FINAL_CONV_BIAS_INITIALIZER = tf.constant_initializer(value=-math.log((1.0 - PROBABILITY) / PROBABILITY)) +WEIGHT_DECAY = 1e-4 + +# ---------------------------------------------Anchor config +LEVEL = ['P3', 'P4', 'P5', 'P6', 'P7'] +BASE_ANCHOR_SIZE_LIST = [32, 64, 128, 256, 512] +ANCHOR_STRIDE = [8, 16, 32, 64, 128] +ANCHOR_SCALES = [2 ** 0, 2 ** (1.0 / 3.0), 2 ** (2.0 / 3.0)] +ANCHOR_RATIOS = [0.5, 1.0, 2.0] +ANCHOR_SCALE_FACTORS = None +USE_CENTER_OFFSET = True + +# --------------------------------------------RPN config +SHARE_NET = True +USE_P5 = True +IOU_POSITIVE_THRESHOLD = 0.5 +IOU_NEGATIVE_THRESHOLD = 0.4 + +NMS = True +NMS_IOU_THRESHOLD = 0.5 +MAXIMUM_DETECTIONS = 100 +FILTERED_SCORE = 0.01 +VIS_SCORE = 0.5 + + diff --git a/libs/configs/cfgs_res50_voc07_v3.py b/libs/configs/cfgs_res50_voc07_v3.py new file mode 100644 index 0000000..3c97086 --- /dev/null +++ b/libs/configs/cfgs_res50_voc07_v3.py @@ -0,0 +1,115 @@ +# -*- coding: utf-8 -*- +from __future__ import division, print_function, absolute_import +import os +import tensorflow as tf +import math + +""" +cls : cat|| Recall: 0.9860335195530726 || Precison: 0.014905206266098045|| AP: 0.8527470573973246 +cls : dog|| Recall: 0.9897750511247444 || Precison: 0.021586905133580126|| AP: 0.8274904377033 +cls : aeroplane|| Recall: 0.9403508771929825 || Precison: 0.02553110412498809|| AP: 0.7767873078576267 +cls : diningtable|| Recall: 0.9805825242718447 || Precison: 0.0015802855466458049|| AP: 0.6266256425436841 +cls : sofa|| Recall: 0.9874476987447699 || Precison: 0.0036989436067834864|| AP: 0.6896703646112717 +cls : chair|| Recall: 0.9523809523809523 || Precison: 0.00560245885694277|| AP: 0.5297096851641577 +cls : boat|| Recall: 0.9467680608365019 || Precison: 0.008553173948887056|| AP: 0.6212390013387435 +cls : horse|| Recall: 0.9683908045977011 || Precison: 0.010542781166901298|| AP: 0.8207037469800831 +cls : motorbike|| Recall: 0.9876923076923076 || Precison: 0.008685064935064934|| AP: 0.7891094623537858 +cls : bus|| Recall: 0.9812206572769953 || Precison: 0.005848280493606067|| AP: 0.7896720643953054 +cls : bottle|| Recall: 0.8848614072494669 || Precison: 0.004798076144890338|| AP: 0.5944787858656694 +cls : tvmonitor|| Recall: 0.961038961038961 || Precison: 0.007717980809345015|| AP: 0.744114515720316 +cls : bicycle|| Recall: 0.9910979228486647 || Precison: 0.006523182688176243|| AP: 0.8000690709871533 +cls : train|| Recall: 0.925531914893617 || Precison: 0.018238993710691823|| AP: 0.7820253371438621 +cls : sheep|| Recall: 0.9710743801652892 || Precison: 0.014397745374341379|| AP: 0.7390184562935749 +cls : car|| Recall: 0.9766860949208993 || Precison: 0.01623844066670358|| AP: 0.8465859465895317 +cls : cow|| Recall: 0.9877049180327869 || Precison: 0.013388145103049831|| AP: 0.7609817867782512 +cls : person|| Recall: 0.974160777385159 || Precison: 0.02294217386329356|| AP: 0.8104809262654363 +cls : bird|| Recall: 0.9477124183006536 || Precison: 0.026685479418440586|| AP: 0.7601748193240988 +cls : pottedplant|| Recall: 0.8729166666666667 || Precison: 0.006048969220996708|| AP: 0.4708156926277445 +mAP is : 0.731625005397046 +""" + +# ------------------------------------------------ +VERSION = 'RetinaNet_20190523' +NET_NAME = 'resnet_v1_50' # 'MobilenetV2' +ADD_BOX_IN_TENSORBOARD = True + +# ---------------------------------------- System_config +ROOT_PATH = os.path.abspath('../') +print(20*"++--") +print(ROOT_PATH) +GPU_GROUP = "0,1,2,3,4,5,6,7" +NUM_GPU = len(GPU_GROUP.strip().split(',')) +SHOW_TRAIN_INFO_INTE = 10 +SMRY_ITER = 100 +SAVE_WEIGHTS_INTE = 5000 * 2 + +SUMMARY_PATH = ROOT_PATH + '/output/summary' +TEST_SAVE_PATH = ROOT_PATH + '/tools/test_result' + +if NET_NAME.startswith("resnet"): + weights_name = NET_NAME +elif NET_NAME.startswith("MobilenetV2"): + weights_name = "mobilenet/mobilenet_v2_1.0_224" +else: + raise Exception('net name must in [resnet_v1_101, resnet_v1_50, MobilenetV2]') + +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/' + +# ------------------------------------------ Train config +RESTORE_FROM_RPN = False +FIXED_BLOCKS = 1 # allow 0~3 +FREEZE_BLOCKS = [True, False, False, False, False] # for gluoncv backbone +USE_07_METRIC = True + +MUTILPY_BIAS_GRADIENT = None # 2.0 # if None, will not multipy +GRADIENT_CLIPPING_BY_NORM = None # 10.0 if None, will not clip + +BATCH_SIZE = 1 +EPSILON = 1e-5 +MOMENTUM = 0.9 +LR = 5e-4 * NUM_GPU * BATCH_SIZE +DECAY_STEP = [SAVE_WEIGHTS_INTE*12, SAVE_WEIGHTS_INTE*16, SAVE_WEIGHTS_INTE*20] +MAX_ITERATION = SAVE_WEIGHTS_INTE*20 +WARM_SETP = int(1.0 / 8.0 * SAVE_WEIGHTS_INTE) + +# -------------------------------------------- Data_preprocess_config +DATASET_NAME = 'pascal' # '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_ = [0.485, 0.456, 0.406] +PIXEL_STD = [0.229, 0.224, 0.225] # R, G, B. In tf, channel is RGB. In openCV, channel is BGR +IMG_SHORT_SIDE_LEN = 600 +IMG_MAX_LENGTH = 1000 +CLASS_NUM = 20 + +# --------------------------------------------- Network_config +BATCH_SIZE = 1 +SUBNETS_WEIGHTS_INITIALIZER = tf.random_normal_initializer(mean=0.0, stddev=0.01, seed=None) +SUBNETS_BIAS_INITIALIZER = tf.constant_initializer(value=0.0) +PROBABILITY = 0.01 +FINAL_CONV_BIAS_INITIALIZER = tf.constant_initializer(value=-math.log((1.0 - PROBABILITY) / PROBABILITY)) +WEIGHT_DECAY = 1e-4 + +# ---------------------------------------------Anchor config +LEVEL = ['P3', 'P4', 'P5', 'P6', 'P7'] +BASE_ANCHOR_SIZE_LIST = [32, 64, 128, 256, 512] +ANCHOR_STRIDE = [8, 16, 32, 64, 128] +ANCHOR_SCALES = [2 ** 0, 2 ** (1.0 / 3.0), 2 ** (2.0 / 3.0)] +ANCHOR_RATIOS = [0.5, 1.0, 2.0] +ANCHOR_SCALE_FACTORS = [10.0, 10.0, 5.0, 5.0] +USE_CENTER_OFFSET = True + +# --------------------------------------------RPN config +SHARE_NET = True +USE_P5 = True +IOU_POSITIVE_THRESHOLD = 0.5 +IOU_NEGATIVE_THRESHOLD = 0.4 + +NMS = True +NMS_IOU_THRESHOLD = 0.5 +MAXIMUM_DETECTIONS = 100 +FILTERED_SCORE = 0.01 +VIS_SCORE = 0.5 + + diff --git a/libs/configs/cfgs_res50_voc07_v4.py b/libs/configs/cfgs_res50_voc07_v4.py new file mode 100644 index 0000000..2269e02 --- /dev/null +++ b/libs/configs/cfgs_res50_voc07_v4.py @@ -0,0 +1,115 @@ +# -*- coding: utf-8 -*- +from __future__ import division, print_function, absolute_import +import os +import tensorflow as tf +import math + +""" +cls : sheep|| Recall: 0.9834710743801653 || Precison: 0.01343721770551039|| AP: 0.7366031642566769 +cls : chair|| Recall: 0.9470899470899471 || Precison: 0.005148153207889042|| AP: 0.5386288781309365 +cls : bus|| Recall: 0.9812206572769953 || Precison: 0.005191127890514393|| AP: 0.8133672291455416 +cls : bicycle|| Recall: 0.9910979228486647 || Precison: 0.009744427587816549|| AP: 0.800899636526437 +cls : motorbike|| Recall: 0.9938461538461538 || Precison: 0.006038963467075496|| AP: 0.7903998534004216 +cls : dog|| Recall: 0.9897750511247444 || Precison: 0.01628204265626051|| AP: 0.8218698566712613 +cls : aeroplane|| Recall: 0.9157894736842105 || Precison: 0.0318603515625|| AP: 0.763830044188939 +cls : bottle|| Recall: 0.8784648187633263 || Precison: 0.004865950159442542|| AP: 0.6133434933374315 +cls : train|| Recall: 0.925531914893617 || Precison: 0.0163125|| AP: 0.7771032196731267 +cls : pottedplant|| Recall: 0.8916666666666667 || Precison: 0.008113590263691683|| AP: 0.4671915218987904 +cls : horse|| Recall: 0.9971264367816092 || Precison: 0.010073738605353306|| AP: 0.8489630879498543 +cls : boat|| Recall: 0.9467680608365019 || Precison: 0.005862271924661566|| AP: 0.5963519636065165 +cls : person|| Recall: 0.9763692579505301 || Precison: 0.02421948186414958|| AP: 0.8160043258059765 +cls : diningtable|| Recall: 0.9757281553398058 || Precison: 0.00147582510371159|| AP: 0.6417165363609527 +cls : car|| Recall: 0.984179850124896 || Precison: 0.01689681790891157|| AP: 0.8698967787733508 +cls : tvmonitor|| Recall: 0.9415584415584416 || Precison: 0.007871878393051032|| AP: 0.7485201769391812 +cls : bird|| Recall: 0.9607843137254902 || Precison: 0.02073635209479475|| AP: 0.7663305161757082 +cls : cat|| Recall: 0.9664804469273743 || Precison: 0.018309784621897654|| AP: 0.8533618661718122 +cls : cow|| Recall: 0.9836065573770492 || Precison: 0.009199279389781134|| AP: 0.7622093974966482 +cls : sofa|| Recall: 0.9916317991631799 || Precison: 0.003074129320967637|| AP: 0.6257163312044963 +mAP is : 0.732615393885703 +""" + +# ------------------------------------------------ +VERSION = 'RetinaNet_20190524' +NET_NAME = 'resnet50_v1d' # 'MobilenetV2' +ADD_BOX_IN_TENSORBOARD = True + +# ---------------------------------------- System_config +ROOT_PATH = os.path.abspath('../') +print(20*"++--") +print(ROOT_PATH) +GPU_GROUP = "0,1,2,3,4,5,6,7" +NUM_GPU = len(GPU_GROUP.strip().split(',')) +SHOW_TRAIN_INFO_INTE = 10 +SMRY_ITER = 100 +SAVE_WEIGHTS_INTE = 5000 * 2 + +SUMMARY_PATH = ROOT_PATH + '/output/summary' +TEST_SAVE_PATH = ROOT_PATH + '/tools/test_result' + +if NET_NAME.startswith("resnet"): + weights_name = NET_NAME +elif NET_NAME.startswith("MobilenetV2"): + weights_name = "mobilenet/mobilenet_v2_1.0_224" +else: + raise Exception('net name must in [resnet_v1_101, resnet_v1_50, MobilenetV2]') + +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/' + +# ------------------------------------------ Train config +RESTORE_FROM_RPN = False +FIXED_BLOCKS = 1 # allow 0~3 +FREEZE_BLOCKS = [True, False, False, False, False] # for gluoncv backbone +USE_07_METRIC = True + +MUTILPY_BIAS_GRADIENT = None # 2.0 # if None, will not multipy +GRADIENT_CLIPPING_BY_NORM = None # 10.0 if None, will not clip + +BATCH_SIZE = 1 +EPSILON = 1e-5 +MOMENTUM = 0.9 +LR = 5e-4 * NUM_GPU * BATCH_SIZE +DECAY_STEP = [SAVE_WEIGHTS_INTE*12, SAVE_WEIGHTS_INTE*16, SAVE_WEIGHTS_INTE*20] +MAX_ITERATION = SAVE_WEIGHTS_INTE*20 +WARM_SETP = int(1.0 / 8.0 * SAVE_WEIGHTS_INTE) + +# -------------------------------------------- Data_preprocess_config +DATASET_NAME = 'pascal' # '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_ = [0.485, 0.456, 0.406] +PIXEL_STD = [0.229, 0.224, 0.225] # R, G, B. In tf, channel is RGB. In openCV, channel is BGR +IMG_SHORT_SIDE_LEN = 600 +IMG_MAX_LENGTH = 1000 +CLASS_NUM = 20 + +# --------------------------------------------- Network_config +BATCH_SIZE = 1 +SUBNETS_WEIGHTS_INITIALIZER = tf.random_normal_initializer(mean=0.0, stddev=0.01, seed=None) +SUBNETS_BIAS_INITIALIZER = tf.constant_initializer(value=0.0) +PROBABILITY = 0.01 +FINAL_CONV_BIAS_INITIALIZER = tf.constant_initializer(value=-math.log((1.0 - PROBABILITY) / PROBABILITY)) +WEIGHT_DECAY = 1e-4 + +# ---------------------------------------------Anchor config +LEVEL = ['P3', 'P4', 'P5', 'P6', 'P7'] +BASE_ANCHOR_SIZE_LIST = [32, 64, 128, 256, 512] +ANCHOR_STRIDE = [8, 16, 32, 64, 128] +ANCHOR_SCALES = [2 ** 0, 2 ** (1.0 / 3.0), 2 ** (2.0 / 3.0)] +ANCHOR_RATIOS = [0.5, 1.0, 2.0] +ANCHOR_SCALE_FACTORS = [10.0, 10.0, 5.0, 5.0] +USE_CENTER_OFFSET = True + +# --------------------------------------------RPN config +SHARE_NET = True +USE_P5 = True +IOU_POSITIVE_THRESHOLD = 0.5 +IOU_NEGATIVE_THRESHOLD = 0.4 + +NMS = True +NMS_IOU_THRESHOLD = 0.5 +MAXIMUM_DETECTIONS = 100 +FILTERED_SCORE = 0.01 +VIS_SCORE = 0.5 + + diff --git a/libs/detection_oprations/__init__.py b/libs/detection_oprations/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/libs/detection_oprations/anchor_target_layer_without_boxweight.py b/libs/detection_oprations/anchor_target_layer_without_boxweight.py new file mode 100644 index 0000000..67423a8 --- /dev/null +++ b/libs/detection_oprations/anchor_target_layer_without_boxweight.py @@ -0,0 +1,63 @@ +# -------------------------------------------------------- +# 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 + +from libs.configs import cfgs +import numpy as np +from libs.box_utils.cython_utils.cython_bbox import bbox_overlaps +from libs.box_utils import bbox_transform + + +def anchor_target_layer(gt_boxes, anchors): + """ + :param gt_boxes: np.array of shape (M, 5) for (x1, y1, x2, y2, label). + :param img_shape: + :param anchors: np.array of annotations of shape (N, 4) for (x1, y1, x2, y2). + :return: + """ + + anchor_states = np.zeros((anchors.shape[0],)) + labels = np.zeros((anchors.shape[0], cfgs.CLASS_NUM)) + if gt_boxes.shape[0]: + # [N, M] + overlaps = bbox_overlaps(np.ascontiguousarray(anchors, dtype=np.float), + np.ascontiguousarray(gt_boxes, dtype=np.float)) + + argmax_overlaps_inds = np.argmax(overlaps, axis=1) + max_overlaps = overlaps[np.arange(overlaps.shape[0]), argmax_overlaps_inds] + + positive_indices = max_overlaps >= cfgs.IOU_POSITIVE_THRESHOLD + ignore_indices = (max_overlaps > cfgs.IOU_NEGATIVE_THRESHOLD) & ~positive_indices + anchor_states[ignore_indices] = -1 + anchor_states[positive_indices] = 1 + + # compute box regression targets + target_boxes = gt_boxes[argmax_overlaps_inds] + + # compute target class labels + labels[positive_indices, target_boxes[positive_indices, 4].astype(int) - 1] = 1 + else: + # no annotations? then everything is background + target_boxes = np.zeros((anchors.shape[0], gt_boxes.shape[1])) + + target_delta = bbox_transform.bbox_transform(ex_rois=anchors, gt_rois=target_boxes) + + return np.array(labels, np.float32), np.array(target_delta, np.float32), np.array(anchor_states, np.float32) + + +if __name__ == '__main__': + anchors = np.array([[0, 0, 4, 4], + [1, 1, 4, 4], + [4, 4, 6, 6]]) + + gt_boxes = np.array([[0, 0, 5, 5, 1]]) + + labels, gt_boxes, anchor_states = anchor_target_layer(gt_boxes, anchors) + + diff --git a/libs/detection_oprations/proposal_opr.py b/libs/detection_oprations/proposal_opr.py new file mode 100644 index 0000000..1fed5af --- /dev/null +++ b/libs/detection_oprations/proposal_opr.py @@ -0,0 +1,67 @@ +# encoding: utf-8 +from libs.configs import cfgs +from libs.box_utils import bbox_transform +from libs.box_utils import boxes_utils +import tensorflow as tf + + +def filter_detections(boxes, scores, is_training): + """ + :param boxes: [-1, 4] + :param scores: [-1, ] + :param labels: [-1, ] + :return: + """ + if is_training: + indices = tf.reshape(tf.where(tf.greater(scores, cfgs.VIS_SCORE)), [-1, ]) + else: + indices = tf.reshape(tf.where(tf.greater(scores, cfgs.FILTERED_SCORE)), [-1, ]) + + if cfgs.NMS: + filtered_boxes = tf.gather(boxes, indices) + filtered_scores = tf.gather(scores, indices) + + # perform NMS + xmin = filtered_boxes[:, 0] + ymin = filtered_boxes[:, 1] + xmax = filtered_boxes[:, 2] + ymax = filtered_boxes[:, 3] + filtered_boxes = tf.transpose(tf.stack([ymin, xmin, ymax, xmax])) + nms_indices = tf.image.non_max_suppression(boxes=filtered_boxes, + scores=filtered_scores, + max_output_size=cfgs.MAXIMUM_DETECTIONS, + iou_threshold=cfgs.NMS_IOU_THRESHOLD) + + # filter indices based on NMS + indices = tf.gather(indices, nms_indices) + + # add indices to list of all indices + return indices + + +def postprocess_detctions(rpn_bbox_pred, rpn_cls_prob, img_shape, anchors, is_training): + + # 1. decode boxes + boxes_pred = bbox_transform.bbox_transform_inv(boxes=anchors, deltas=rpn_bbox_pred) + + # 2. clip to img boundaries + boxes_pred = boxes_utils.clip_boxes_to_img_boundaries(boxes=boxes_pred, + img_shape=img_shape) + + return_boxes_pred = [] + return_scores = [] + return_labels = [] + for j in range(0, cfgs.CLASS_NUM): + indices = filter_detections(boxes_pred, rpn_cls_prob[:, j], is_training) + tmp_boxes_pred = tf.reshape(tf.gather(boxes_pred, indices), [-1, 4]) + tmp_scores = tf.reshape(tf.gather(rpn_cls_prob[:, j], indices), [-1, ]) + + return_boxes_pred.append(tmp_boxes_pred) + return_scores.append(tmp_scores) + return_labels.append(tf.ones_like(tmp_scores)*(j+1)) + + return_boxes_pred = tf.concat(return_boxes_pred, axis=0) + return_scores = tf.concat(return_scores, axis=0) + return_labels = tf.concat(return_labels, axis=0) + + return return_boxes_pred, return_scores, return_labels diff --git a/libs/label_name_dict/__init__.py b/libs/label_name_dict/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/libs/label_name_dict/coco_dict.py b/libs/label_name_dict/coco_dict.py new file mode 100644 index 0000000..dbeb17c --- /dev/null +++ b/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/libs/label_name_dict/label_dict.py b/libs/label_name_dict/label_dict.py new file mode 100644 index 0000000..88f6ed2 --- /dev/null +++ b/libs/label_name_dict/label_dict.py @@ -0,0 +1,135 @@ +# -*- coding: utf-8 -*- +from __future__ import division, print_function, absolute_import + +from libs.configs import cfgs + + +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} + + +def get_coco_label_dict(): + originID_classes = {item: key for key, item in classes_originID.items()} + NAME_LABEL_MAP = dict(zip(class_names, range(len(class_names)))) + return NAME_LABEL_MAP + + +if cfgs.DATASET_NAME == 'WIDER': + NAME_LABEL_MAP = { + 'back_ground': 0, + 'face': 1 + } +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 == 'coco': + NAME_LABEL_MAP = get_coco_label_dict() +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 == 'bdd100k': + NAME_LABEL_MAP = { + 'back_ground': 0, + 'bus': 1, + 'traffic light': 2, + 'traffic sign': 3, + 'person': 4, + 'bike': 5, + 'truck': 6, + 'motor': 7, + 'car': 8, + 'train': 9, + 'rider': 10 + } +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/libs/losses/__init__.py b/libs/losses/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/libs/losses/losses.py b/libs/losses/losses.py new file mode 100644 index 0000000..943fc59 --- /dev/null +++ b/libs/losses/losses.py @@ -0,0 +1,124 @@ +# -*- coding: utf-8 -*- +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import tensorflow as tf + + +def focal_loss_(labels, pred, anchor_state, alpha=0.25, gamma=2.0): + + # filter out "ignore" anchors + indices = tf.reshape(tf.where(tf.not_equal(anchor_state, -1)), [-1, ]) + labels = tf.gather(labels, indices) + pred = tf.gather(pred, indices) + + logits = tf.cast(pred, tf.float32) + onehot_labels = tf.cast(labels, tf.float32) + ce = tf.nn.sigmoid_cross_entropy_with_logits(labels=onehot_labels, logits=logits) + predictions = tf.sigmoid(logits) + predictions_pt = tf.where(tf.equal(onehot_labels, 1), predictions, 1.-predictions) + alpha_t = tf.scalar_mul(alpha, tf.ones_like(onehot_labels, dtype=tf.float32)) + alpha_t = tf.where(tf.equal(onehot_labels, 1.0), alpha_t, 1-alpha_t) + loss = ce * tf.pow(1-predictions_pt, gamma) * alpha_t + positive_mask = tf.cast(tf.greater(labels, 0), tf.float32) + return tf.reduce_sum(loss) / tf.maximum(tf.reduce_sum(positive_mask), 1) + + +def focal_loss(labels, pred, anchor_state, alpha=0.25, gamma=2.0): + + # filter out "ignore" anchors + indices = tf.reshape(tf.where(tf.not_equal(anchor_state, -1)), [-1, ]) + labels = tf.gather(labels, indices) + pred = tf.gather(pred, indices) + + # compute the focal loss + per_entry_cross_ent = (tf.nn.sigmoid_cross_entropy_with_logits( + labels=labels, logits=pred)) + prediction_probabilities = tf.sigmoid(pred) + p_t = ((labels * prediction_probabilities) + + ((1 - labels) * (1 - prediction_probabilities))) + modulating_factor = 1.0 + if gamma: + modulating_factor = tf.pow(1.0 - p_t, gamma) + alpha_weight_factor = 1.0 + if alpha is not None: + alpha_weight_factor = (labels * alpha + + (1 - labels) * (1 - alpha)) + focal_cross_entropy_loss = (modulating_factor * alpha_weight_factor * + per_entry_cross_ent) + + # compute the normalizer: the number of positive anchors + normalizer = tf.stop_gradient(tf.where(tf.equal(anchor_state, 1))) + normalizer = tf.cast(tf.shape(normalizer)[0], tf.float32) + normalizer = tf.maximum(1.0, normalizer) + + return tf.reduce_sum(focal_cross_entropy_loss) / normalizer + + +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_rcnn(bbox_targets, bbox_pred, anchor_state, sigma=3.0): + + outside_mask = tf.stop_gradient(tf.to_float(tf.greater(anchor_state, 0))) + + bbox_pred = tf.reshape(bbox_pred, [-1, 1, 4]) + bbox_targets = tf.reshape(bbox_targets, [-1, 1, 4]) + + value = _smooth_l1_loss_base(bbox_pred, + bbox_targets, + sigma=sigma) + value = tf.reduce_sum(value, 2) + value = tf.reshape(value, [-1, 1]) + + normalizer = tf.stop_gradient(tf.where(tf.equal(anchor_state, 1))) + normalizer = tf.cast(tf.shape(normalizer)[0], tf.float32) + normalizer = tf.maximum(1.0, normalizer) + + bbox_loss = tf.reduce_sum( + tf.reduce_sum(value, 1)*outside_mask) / normalizer + + return bbox_loss + + +def smooth_l1_loss(targets, preds, anchor_state, sigma=3.0): + + sigma_squared = sigma ** 2 + indices = tf.reshape(tf.where(tf.equal(anchor_state, 1)), [-1, ]) + preds = tf.gather(preds, indices) + targets = tf.gather(targets, indices) + + # compute smooth L1 loss + # f(x) = 0.5 * (sigma * x)^2 if |x| < 1 / sigma / sigma + # |x| - 0.5 / sigma / sigma otherwise + regression_diff = preds - targets + regression_diff = tf.abs(regression_diff) + regression_loss = tf.where( + tf.less(regression_diff, 1.0 / sigma_squared), + 0.5 * sigma_squared * tf.pow(regression_diff, 2), + regression_diff - 0.5 / sigma_squared + ) + + normalizer = tf.stop_gradient(tf.where(tf.equal(anchor_state, 1))) + normalizer = tf.cast(tf.shape(normalizer)[0], tf.float32) + normalizer = tf.maximum(1.0, normalizer) + return tf.reduce_sum(regression_loss) / normalizer diff --git a/libs/networks/__init__.py b/libs/networks/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/libs/networks/build_whole_network.py b/libs/networks/build_whole_network.py new file mode 100644 index 0000000..e5637ee --- /dev/null +++ b/libs/networks/build_whole_network.py @@ -0,0 +1,353 @@ +# -*-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, resnet_gluoncv, mobilenet_v2, xception +from libs.box_utils import anchor_utils, generate_anchors +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_detctions +from libs.detection_oprations.anchor_target_layer_without_boxweight import anchor_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 in ['resnet101_v1d', 'resnet50_v1d']: + + return resnet_gluoncv.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) + + elif self.base_network_name.startswith('xception'): + return xception.xception_base(input_img_batch, is_training=self.is_training) + + else: + raise ValueError('Sry, we only support resnet, mobilenet_v2 and xception') + + def rpn_cls_net(self, inputs, scope_list, reuse_flag, level): + rpn_conv2d_3x3 = inputs + for i in range(4): + rpn_conv2d_3x3 = slim.conv2d(inputs=rpn_conv2d_3x3, + num_outputs=256, + kernel_size=[3, 3], + stride=1, + activation_fn=tf.nn.relu, + weights_initializer=cfgs.SUBNETS_WEIGHTS_INITIALIZER, + biases_initializer=cfgs.SUBNETS_BIAS_INITIALIZER, + scope='{}_{}'.format(scope_list[0], i), + reuse=reuse_flag) + + rpn_box_scores = slim.conv2d(rpn_conv2d_3x3, + num_outputs=cfgs.CLASS_NUM * self.num_anchors_per_location, + kernel_size=[3, 3], + stride=1, + weights_initializer=cfgs.SUBNETS_WEIGHTS_INITIALIZER, + biases_initializer=cfgs.FINAL_CONV_BIAS_INITIALIZER, + scope=scope_list[2], + activation_fn=None, + reuse=reuse_flag) + + rpn_box_scores = tf.reshape(rpn_box_scores, [-1, cfgs.CLASS_NUM], + name='rpn_{}_classification_reshape'.format(level)) + rpn_box_probs = tf.sigmoid(rpn_box_scores, name='rpn_{}_classification_sigmoid'.format(level)) + + return rpn_box_scores, rpn_box_probs + + def rpn_reg_net(self, inputs, scope_list, reuse_flag, level): + rpn_delta_boxes = inputs + for i in range(4): + rpn_delta_boxes = slim.conv2d(inputs=rpn_delta_boxes, + num_outputs=256, + kernel_size=[3, 3], + weights_initializer=cfgs.SUBNETS_WEIGHTS_INITIALIZER, + biases_initializer=cfgs.SUBNETS_BIAS_INITIALIZER, + stride=1, + activation_fn=tf.nn.relu, + scope='{}_{}'.format(scope_list[1], i), + reuse=reuse_flag) + + rpn_delta_boxes = slim.conv2d(rpn_delta_boxes, + num_outputs=4 * self.num_anchors_per_location, + kernel_size=[3, 3], + stride=1, + weights_initializer=cfgs.SUBNETS_WEIGHTS_INITIALIZER, + biases_initializer=cfgs.SUBNETS_BIAS_INITIALIZER, + scope=scope_list[3], + activation_fn=None, + reuse=reuse_flag) + + rpn_delta_boxes = tf.reshape(rpn_delta_boxes, [-1, 4], name='rpn_{}_regression_reshape'.format(level)) + return rpn_delta_boxes + + def rpn_net(self, feature_pyramid): + + rpn_delta_boxes_list = [] + rpn_scores_list = [] + rpn_probs_list = [] + with tf.variable_scope('rpn_net'): + with slim.arg_scope([slim.conv2d], weights_regularizer=slim.l2_regularizer(cfgs.WEIGHT_DECAY)): + for level in cfgs.LEVEL: + + if cfgs.SHARE_NET: + reuse_flag = None if level == 'P3' else True + scope_list = ['conv2d_3x3_cls', 'conv2d_3x3_reg', 'rpn_classification', 'rpn_regression'] + else: + reuse_flag = None + scope_list = ['conv2d_3x3_cls_' + level, 'conv2d_3x3_reg_' + level, + 'rpn_classification_' + level, 'rpn_regression_' + level] + + rpn_box_scores, rpn_box_probs = self.rpn_cls_net(feature_pyramid[level], scope_list, reuse_flag, level) + rpn_delta_boxes = self.rpn_reg_net(feature_pyramid[level], scope_list, reuse_flag, level) + + rpn_scores_list.append(rpn_box_scores) + rpn_probs_list.append(rpn_box_probs) + rpn_delta_boxes_list.append(rpn_delta_boxes) + + rpn_all_delta_boxes = tf.concat(rpn_delta_boxes_list, axis=0) + rpn_all_boxes_scores = tf.concat(rpn_scores_list, axis=0) + rpn_all_boxes_probs = tf.concat(rpn_probs_list, axis=0) + + return rpn_all_delta_boxes, rpn_all_boxes_scores, rpn_all_boxes_probs + + def make_anchors(self, feature_pyramid): + with tf.variable_scope('make_anchors'): + anchor_list = [] + level_list = cfgs.LEVEL + with tf.name_scope('make_anchors_all_level'): + for level, base_anchor_size, stride in zip(level_list, cfgs.BASE_ANCHOR_SIZE_LIST, cfgs.ANCHOR_STRIDE): + ''' + (level, base_anchor_size) tuple: + (P3, 32), (P4, 64), (P5, 128), (P6, 256), (P7, 512) + ''' + featuremap_height, featuremap_width = tf.shape(feature_pyramid[level])[1], \ + tf.shape(feature_pyramid[level])[2] + + featuremap_height = tf.cast(featuremap_height, tf.float32) + featuremap_width = tf.cast(featuremap_width, tf.float32) + + # tmp_anchors = anchor_utils.make_anchors(base_anchor_size=base_anchor_size, + # anchor_scales=cfgs.ANCHOR_SCALES, + # anchor_ratios=cfgs.ANCHOR_RATIOS, + # featuremap_height=featuremap_height, + # featuremap_width=featuremap_width, + # stride=stride, + # name='make_anchors_{}'.format(level)) + + tmp_anchors = tf.py_func(generate_anchors.generate_anchors_pre, + inp=[featuremap_height, featuremap_width, stride, + np.array(cfgs.ANCHOR_SCALES) * stride, cfgs.ANCHOR_RATIOS, 4.0], + Tout=[tf.float32]) + + tmp_anchors = tf.reshape(tmp_anchors, [-1, 4]) + anchor_list.append(tmp_anchors) + + all_level_anchors = tf.concat(anchor_list, axis=0) + return all_level_anchors + + 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 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 + feature_pyramid = self.build_base_network(input_img_batch) + + # 2. build rpn + rpn_box_pred, rpn_cls_score, rpn_cls_prob = self.rpn_net(feature_pyramid) + + # 3. generate_anchors + anchors = self.make_anchors(feature_pyramid) + + # 4. postprocess rpn proposals. such as: decode, clip, filter + if not self.is_training: + with tf.variable_scope('postprocess_detctions'): + boxes, scores, category = postprocess_detctions(rpn_bbox_pred=rpn_box_pred, + rpn_cls_prob=rpn_cls_prob, + img_shape=img_shape, + anchors=anchors, + is_training=self.is_training) + return boxes, scores, category + + # 5. build loss + else: + with tf.variable_scope('build_loss'): + labels, target_delta, anchor_states = tf.py_func(func=anchor_target_layer, + inp=[gtboxes_batch, anchors], + Tout=[tf.float32, tf.float32, tf.float32]) + + self.add_anchor_img_smry(input_img_batch, anchors, anchor_states) + + cls_loss = losses.focal_loss(labels, rpn_cls_score, anchor_states) + + reg_loss = losses.smooth_l1_loss(target_delta, rpn_box_pred, anchor_states) + + losses_dict = {'cls_loss': cls_loss, 'reg_loss': reg_loss * 2} + + with tf.variable_scope('postprocess_detctions'): + boxes, scores, category = postprocess_detctions(rpn_bbox_pred=rpn_box_pred, + rpn_cls_prob=rpn_cls_prob, + img_shape=img_shape, + anchors=anchors, + is_training=self.is_training) + boxes = tf.stop_gradient(boxes) + scores = tf.stop_gradient(scores) + category = tf.stop_gradient(category) + + return boxes, scores, category, losses_dict + + def get_restorer(self): + checkpoint_path = tf.train.latest_checkpoint(os.path.join(cfgs.TRAINED_CKPT, cfgs.VERSION)) + + if checkpoint_path != None: + if cfgs.RESTORE_FROM_RPN: + print('___restore from rpn___') + model_variables = slim.get_model_variables() + restore_variables = [var for var in model_variables if not var.name.startswith('FastRCNN_Head')] + \ + [slim.get_or_create_global_step()] + for var in restore_variables: + print(var.name) + restorer = tf.train.Saver(restore_variables) + else: + 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('Fast-RCNN/'+self.base_network_name): # +'/block4' + var_name_in_ckpt = name_in_ckpt_fastrcnn_head(var) + nameInCkpt_Var_dict[var_name_in_ckpt] = var + else: + 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 + else: + continue + 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/libs/networks/mobilenet/README.md b/libs/networks/mobilenet/README.md new file mode 100644 index 0000000..95664d6 --- /dev/null +++ b/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/libs/networks/mobilenet/__init__.py b/libs/networks/mobilenet/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/libs/networks/mobilenet/conv_blocks.py b/libs/networks/mobilenet/conv_blocks.py new file mode 100644 index 0000000..643bb88 --- /dev/null +++ b/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/libs/networks/mobilenet/mobilenet.py b/libs/networks/mobilenet/mobilenet.py new file mode 100644 index 0000000..5df4f0b --- /dev/null +++ b/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/libs/networks/mobilenet/mobilenet_v2.py b/libs/networks/mobilenet/mobilenet_v2.py new file mode 100644 index 0000000..0daa3bd --- /dev/null +++ b/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/libs/networks/mobilenet/mobilenet_v2_test.py b/libs/networks/mobilenet/mobilenet_v2_test.py new file mode 100644 index 0000000..1875224 --- /dev/null +++ b/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/libs/networks/mobilenet_v2.py b/libs/networks/mobilenet_v2.py new file mode 100644 index 0000000..a5608ce --- /dev/null +++ b/libs/networks/mobilenet_v2.py @@ -0,0 +1,127 @@ +# -*- 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/libs/networks/resnet.py b/libs/networks/resnet.py new file mode 100644 index 0000000..b525b21 --- /dev/null +++ b/libs/networks/resnet.py @@ -0,0 +1,202 @@ +# -*- 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): + + 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. ') + + 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)], + } + + 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(feature_dict['C5'], + num_outputs=256, + kernel_size=[1, 1], + stride=1, scope='build_P5') + + pyramid_dict['P5'] = P5 + + for level in range(4, 2, -1): # build [P4, P3] + + 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(5, 2, -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) + + p6 = slim.conv2d(pyramid_dict['P5'] if cfgs.USE_P5 else feature_dict['C5'], + num_outputs=256, kernel_size=[3, 3], padding="SAME", + stride=2, scope='p6_conv') + pyramid_dict['P6'] = p6 + + p7 = tf.nn.relu(p6, name='p6_relu') + + p7 = slim.conv2d(p7, + num_outputs=256, kernel_size=[3, 3], padding="SAME", + stride=2, scope='p7_conv') + + pyramid_dict['P7'] = p7 + + # for level in range(7, 1, -1): + # add_heatmap(pyramid_dict['P%d' % level], name='Layer%d/P%d_heat' % (level, level)) + + return pyramid_dict diff --git a/libs/networks/resnet_gluoncv.py b/libs/networks/resnet_gluoncv.py new file mode 100644 index 0000000..4b51d81 --- /dev/null +++ b/libs/networks/resnet_gluoncv.py @@ -0,0 +1,266 @@ +# -*- coding: utf-8 -*- +from __future__ import absolute_import, division, print_function +import tensorflow as tf +import tensorflow.contrib.slim as slim + +from libs.configs import cfgs +from libs.networks.resnet import fusion_two_layer +DATA_FORMAT = "NHWC" +DEBUG = False +debug_dict = {} +BottleNeck_NUM_DICT = { + 'resnet50_v1b': [3, 4, 6, 3], + 'resnet101_v1b': [3, 4, 23, 3], + 'resnet50_v1d': [3, 4, 6, 3], + 'resnet101_v1d': [3, 4, 23, 3] +} + +BASE_CHANNELS_DICT = { + 'resnet50_v1b': [64, 128, 256, 512], + 'resnet101_v1b': [64, 128, 256, 512], + 'resnet50_v1d': [64, 128, 256, 512], + 'resnet101_v1d': [64, 128, 256, 512] +} + + +def resnet_arg_scope(freeze_norm, is_training=True, weight_decay=0.0001, + batch_norm_decay=0.9, batch_norm_epsilon=1e-5, batch_norm_scale=True): + + 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, + 'data_format': DATA_FORMAT + } + 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 stem_7x7(net, scope="C1"): + + with tf.variable_scope(scope): + net = tf.pad(net, paddings=[[0, 0], [3, 3], [3, 3], [0, 0]]) # pad for data + net = slim.conv2d(net, num_outputs=64, kernel_size=[7, 7], stride=2, + padding="VALID", biases_initializer=None, data_format=DATA_FORMAT, + scope="conv0") + if DEBUG: + debug_dict['conv_7x7_bn_relu'] = tf.transpose(net, [0, 3, 1, 2]) # NHWC --> NCHW + net = tf.pad(net, paddings=[[0, 0], [1, 1], [1, 1], [0, 0]]) + net = slim.max_pool2d(net, kernel_size=[3, 3], stride=2, padding="VALID", data_format=DATA_FORMAT) + return net + + +def stem_stack_3x3(net, input_channel=32, scope="C1"): + with tf.variable_scope(scope): + net = tf.pad(net, paddings=[[0, 0], [1, 1], [1, 1], [0, 0]]) + net = slim.conv2d(net, num_outputs=input_channel, kernel_size=[3, 3], stride=2, + padding="VALID", biases_initializer=None, data_format=DATA_FORMAT, + scope='conv0') + net = tf.pad(net, paddings=[[0, 0], [1, 1], [1, 1], [0, 0]]) + net = slim.conv2d(net, num_outputs=input_channel, kernel_size=[3, 3], stride=1, + padding="VALID", biases_initializer=None, data_format=DATA_FORMAT, + scope='conv1') + net = tf.pad(net, paddings=[[0, 0], [1, 1], [1, 1], [0, 0]]) + net = slim.conv2d(net, num_outputs=input_channel*2, kernel_size=[3, 3], stride=1, + padding="VALID", biases_initializer=None, data_format=DATA_FORMAT, + scope='conv2') + net = tf.pad(net, paddings=[[0, 0], [1, 1], [1, 1], [0, 0]]) + net = slim.max_pool2d(net, kernel_size=[3, 3], stride=2, padding="VALID", data_format=DATA_FORMAT) + return net + + +def bottleneck_v1b(input_x, base_channel, scope, stride=1, projection=False, avg_down=True): + ''' + for bottleneck_v1b: reduce spatial dim in conv_3x3 with stride 2. + ''' + with tf.variable_scope(scope): + if DEBUG: + debug_dict[input_x.op.name] = tf.transpose(input_x, [0, 3, 1, 2]) + net = slim.conv2d(input_x, num_outputs=base_channel, kernel_size=[1, 1], stride=1, + padding="VALID", biases_initializer=None, data_format=DATA_FORMAT, + scope='conv0') + if DEBUG: + debug_dict[net.op.name] = tf.transpose(net, [0, 3, 1, 2]) + + net = tf.pad(net, paddings=[[0, 0], [1, 1], [1, 1], [0, 0]]) + if DEBUG: + debug_dict[net.op.name] = tf.transpose(net, [0, 3, 1, 2]) + + net = slim.conv2d(net, num_outputs=base_channel, kernel_size=[3, 3], stride=stride, + padding="VALID", biases_initializer=None, data_format=DATA_FORMAT, + scope='conv1') + if DEBUG: + debug_dict[net.op.name] = tf.transpose(net, [0, 3, 1, 2]) + net = slim.conv2d(net, num_outputs=base_channel * 4, kernel_size=[1, 1], stride=1, + padding="VALID", biases_initializer=None, data_format=DATA_FORMAT, + activation_fn=None, scope='conv2') + if DEBUG: + debug_dict[net.op.name] = tf.transpose(net, [0, 3, 1, 2]) + # Note that : gamma in the last conv should be init with 0. + # But we just reload params from mxnet, so don't specific batch norm initializer + if projection: + + if avg_down: # design for resnet_v1d + ''' + In GluonCV, padding is "ceil mode". Here we use "SAME" to replace it, which may cause Erros. + And the erro will grow with depth of resnet. e.g. res101 erro > res50 erro + ''' + shortcut = slim.avg_pool2d(input_x, kernel_size=[stride, stride], stride=stride, padding="SAME", + data_format=DATA_FORMAT) + if DEBUG: + debug_dict[shortcut.op.name] = tf.transpose(shortcut, [0, 3, 1, 2]) + + shortcut = slim.conv2d(shortcut, num_outputs=base_channel*4, kernel_size=[1, 1], + stride=1, padding="VALID", biases_initializer=None, data_format=DATA_FORMAT, + activation_fn=None, + scope='shortcut') + if DEBUG: + debug_dict[shortcut.op.name] = tf.transpose(shortcut, [0, 3, 1, 2]) + # shortcut should have batch norm. + else: + shortcut = slim.conv2d(input_x, num_outputs=base_channel * 4, kernel_size=[1, 1], + stride=stride, padding="VALID", biases_initializer=None, activation_fn=None, + data_format=DATA_FORMAT, + scope='shortcut') + if DEBUG: + debug_dict[shortcut.op.name] = tf.transpose(shortcut, [0, 3, 1, 2]) + else: + shortcut = tf.identity(input_x, name='shortcut/Identity') + if DEBUG: + debug_dict[shortcut.op.name] = tf.transpose(shortcut, [0, 3, 1, 2]) + + net = net + shortcut + if DEBUG: + debug_dict[net.op.name] = tf.transpose(net, [0, 3, 1, 2]) + net = tf.nn.relu(net) + if DEBUG: + debug_dict[net.op.name] = tf.transpose(net, [0, 3, 1, 2]) + return net + + +def make_block(net, base_channel, bottleneck_nums, scope, avg_down=True, spatial_downsample=False): + with tf.variable_scope(scope): + first_stride = 2 if spatial_downsample else 1 + + net = bottleneck_v1b(input_x=net, base_channel=base_channel,scope='bottleneck_0', + stride=first_stride, avg_down=avg_down, projection=True) + for i in range(1, bottleneck_nums): + net = bottleneck_v1b(input_x=net, base_channel=base_channel, scope="bottleneck_%d" % i, + stride=1, avg_down=avg_down, projection=False) + return net + + +def get_resnet_v1_b_base(input_x, freeze_norm, scope="resnet50_v1b", bottleneck_nums=[3, 4, 6, 3], base_channels=[64, 128, 256, 512], + freeze=[True, False, False, False, False], is_training=True): + + assert len(bottleneck_nums) == len(base_channels), "bottleneck num should same as base_channels size" + assert len(freeze) == len(bottleneck_nums) +1, "should satisfy:: len(freeze) == len(bottleneck_nums) + 1" + feature_dict = {} + with tf.variable_scope(scope): + with slim.arg_scope(resnet_arg_scope(is_training=(not freeze[0]) and is_training, + freeze_norm=freeze_norm)): + net = stem_7x7(net=input_x, scope="C1") + feature_dict["C1"] = net + for i in range(2, len(bottleneck_nums)+2): + spatial_downsample = False if i == 2 else True + with slim.arg_scope(resnet_arg_scope(is_training=(not freeze[i-1]) and is_training, + freeze_norm=freeze_norm)): + net = make_block(net=net, base_channel=base_channels[i-2], + bottleneck_nums=bottleneck_nums[i-2], + scope="C%d" % i, + avg_down=False, spatial_downsample=spatial_downsample) + feature_dict["C%d" % i] = net + + return net, feature_dict + + +def get_resnet_v1_d_base(input_x, freeze_norm, scope="resnet50_v1d", bottleneck_nums=[3, 4, 6, 3], base_channels=[64, 128, 256, 512], + freeze=[True, False, False, False, False], is_training=True): + + assert len(bottleneck_nums) == len(base_channels), "bottleneck num should same as base_channels size" + assert len(freeze) == len(bottleneck_nums) + 1, "should satisfy:: len(freeze) == len(bottleneck_nums) + 1" + feature_dict = {} + with tf.variable_scope(scope): + with slim.arg_scope(resnet_arg_scope(is_training=((not freeze[0]) and is_training), + freeze_norm=freeze_norm)): + net = stem_stack_3x3(net=input_x, input_channel=32, scope="C1") + feature_dict["C1"] = net + # print (net) + for i in range(2, len(bottleneck_nums)+2): + spatial_downsample = False if i == 2 else True # do not downsample in C2 + with slim.arg_scope(resnet_arg_scope(is_training=((not freeze[i-1]) and is_training), + freeze_norm=freeze_norm)): + net = make_block(net=net, base_channel=base_channels[i-2], + bottleneck_nums=bottleneck_nums[i-2], + scope="C%d" % i, + avg_down=True, spatial_downsample=spatial_downsample) + feature_dict["C%d" % i] = net + + return net, feature_dict + + +# ----------------------------------- +def resnet_base(img_batch, scope_name, is_training=True): + if scope_name.endswith('b'): + get_resnet_fn = get_resnet_v1_b_base + elif scope_name.endswith('d'): + get_resnet_fn = get_resnet_v1_d_base + else: + raise ValueError("scope Name erro....") + + _, feature_dict = get_resnet_fn(input_x=img_batch, scope=scope_name, + bottleneck_nums=BottleNeck_NUM_DICT[scope_name], + base_channels=BASE_CHANNELS_DICT[scope_name], + is_training=is_training, freeze_norm=True, + freeze=cfgs.FREEZE_BLOCKS) + + 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(feature_dict['C5'], + num_outputs=256, + kernel_size=[1, 1], + stride=1, scope='build_P5') + + pyramid_dict['P5'] = P5 + + for level in range(4, 2, -1): # build [P4, P3] + + 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(5, 2, -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) + + p6 = slim.conv2d(pyramid_dict['P5'] if cfgs.USE_P5 else feature_dict['C5'], + num_outputs=256, kernel_size=[3, 3], padding="SAME", + stride=2, scope='p6_conv') + pyramid_dict['P6'] = p6 + + p7 = tf.nn.relu(p6, name='p6_relu') + + p7 = slim.conv2d(p7, + num_outputs=256, kernel_size=[3, 3], padding="SAME", + stride=2, scope='p7_conv') + + pyramid_dict['P7'] = p7 + + # for level in range(7, 1, -1): + # add_heatmap(pyramid_dict['P%d' % level], name='Layer%d/P%d_heat' % (level, level)) + + return pyramid_dict + + diff --git a/libs/networks/slim_nets/__init__.py b/libs/networks/slim_nets/__init__.py new file mode 100644 index 0000000..d3f5a12 --- /dev/null +++ b/libs/networks/slim_nets/__init__.py @@ -0,0 +1 @@ + diff --git a/libs/networks/slim_nets/alexnet.py b/libs/networks/slim_nets/alexnet.py new file mode 100644 index 0000000..86ae7e7 --- /dev/null +++ b/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/libs/networks/slim_nets/alexnet_test.py b/libs/networks/slim_nets/alexnet_test.py new file mode 100644 index 0000000..e729ee4 --- /dev/null +++ b/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/libs/networks/slim_nets/cifarnet.py b/libs/networks/slim_nets/cifarnet.py new file mode 100644 index 0000000..45c94aa --- /dev/null +++ b/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/libs/networks/slim_nets/inception.py b/libs/networks/slim_nets/inception.py new file mode 100644 index 0000000..c4ae499 --- /dev/null +++ b/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/libs/networks/slim_nets/inception_resnet_v2.py b/libs/networks/slim_nets/inception_resnet_v2.py new file mode 100644 index 0000000..f006b34 --- /dev/null +++ b/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/libs/networks/slim_nets/inception_resnet_v2_test.py b/libs/networks/slim_nets/inception_resnet_v2_test.py new file mode 100644 index 0000000..c857ebc --- /dev/null +++ b/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/libs/networks/slim_nets/inception_utils.py b/libs/networks/slim_nets/inception_utils.py new file mode 100644 index 0000000..ff6e009 --- /dev/null +++ b/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/libs/networks/slim_nets/inception_v1.py b/libs/networks/slim_nets/inception_v1.py new file mode 100644 index 0000000..0f976c2 --- /dev/null +++ b/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/libs/networks/slim_nets/inception_v1_test.py b/libs/networks/slim_nets/inception_v1_test.py new file mode 100644 index 0000000..3ff157f --- /dev/null +++ b/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/libs/networks/slim_nets/inception_v2.py b/libs/networks/slim_nets/inception_v2.py new file mode 100644 index 0000000..c38b51c --- /dev/null +++ b/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/libs/networks/slim_nets/inception_v2_test.py b/libs/networks/slim_nets/inception_v2_test.py new file mode 100644 index 0000000..ef1a6a5 --- /dev/null +++ b/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/libs/networks/slim_nets/inception_v3.py b/libs/networks/slim_nets/inception_v3.py new file mode 100644 index 0000000..158cd9d --- /dev/null +++ b/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/libs/networks/slim_nets/inception_v3_test.py b/libs/networks/slim_nets/inception_v3_test.py new file mode 100644 index 0000000..8df6f29 --- /dev/null +++ b/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/libs/networks/slim_nets/inception_v4.py b/libs/networks/slim_nets/inception_v4.py new file mode 100644 index 0000000..c271723 --- /dev/null +++ b/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/libs/networks/slim_nets/inception_v4_test.py b/libs/networks/slim_nets/inception_v4_test.py new file mode 100644 index 0000000..704ff35 --- /dev/null +++ b/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/libs/networks/slim_nets/lenet.py b/libs/networks/slim_nets/lenet.py new file mode 100644 index 0000000..383d94b --- /dev/null +++ b/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/libs/networks/slim_nets/mobilenet_v1.md b/libs/networks/slim_nets/mobilenet_v1.md new file mode 100644 index 0000000..369da0b --- /dev/null +++ b/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/libs/networks/slim_nets/mobilenet_v1.png b/libs/networks/slim_nets/mobilenet_v1.png new file mode 100644 index 0000000000000000000000000000000000000000..a458345174a12073a653e26d6747914a4e58e516 GIT binary patch literal 100916 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 z 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
28S;~r`@&Z*|%K=(VQZy942UO zhl$jx^mqjC;Dd(0xV6l>tAqrvc7L#RS_1PT%FG--rbqPfFb$ofS|y#BQ(9I)zR`7= z%IJ2RA1}?)&F<87$q>0qy!Up0R)hKy;WD&yGG>3bg<>)^WdF~MrGrvkz{ z#e0xj97Y4(nR(3XS9OM6SV~*-vfZq0L?mHasNT!3!&c2WhO<-!Eeu1CVvaBk>bUGfVUSkHEAc{ z7P`OQbzoRJ02BMB%ieQn4)MBzUaMz?KLakKcCA%j`GC3K`BSKFzdxfyvOH6PovYvG zhdPbVl%9Bhd)c=;NvBHqZ>A#j9XkBUOXhAF5QU%l7al*3;!Aw-Ng@bW`J^dWoP;2Zt0%=RmVB0k7b+{;?Gg>XMIHd)(PW4Mb-ic#2QX|=9gi`U4yZ-ckk0Yj zu4=T&2!dkyU6eqGOldh?rd0o0&@&g-3Ai!UF8odBiNZfO2&1P0fvDhOD(VywdwIe3 zd6+BN^?pjnR%RsKtELin^8kQbG}my17_7H5Egp#gzt>mWAQEsdK__I@ZJEu_XMGRN z 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 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/libs/networks/slim_nets/mobilenet_v1_test.py b/libs/networks/slim_nets/mobilenet_v1_test.py new file mode 100644 index 0000000..e00e456 --- /dev/null +++ b/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/libs/networks/slim_nets/nets_factory.py b/libs/networks/slim_nets/nets_factory.py new file mode 100644 index 0000000..8c3d1a9 --- /dev/null +++ b/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/libs/networks/slim_nets/nets_factory_test.py b/libs/networks/slim_nets/nets_factory_test.py new file mode 100644 index 0000000..cebbbcf --- /dev/null +++ b/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/libs/networks/slim_nets/overfeat.py b/libs/networks/slim_nets/overfeat.py new file mode 100644 index 0000000..5bcfe31 --- /dev/null +++ b/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/libs/networks/slim_nets/overfeat_test.py b/libs/networks/slim_nets/overfeat_test.py new file mode 100644 index 0000000..861c759 --- /dev/null +++ b/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/libs/networks/slim_nets/resnet_utils.py b/libs/networks/slim_nets/resnet_utils.py new file mode 100644 index 0000000..68d167c --- /dev/null +++ b/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/libs/networks/slim_nets/resnet_v1.py b/libs/networks/slim_nets/resnet_v1.py new file mode 100644 index 0000000..c4269d6 --- /dev/null +++ b/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/libs/networks/slim_nets/resnet_v1_test.py b/libs/networks/slim_nets/resnet_v1_test.py new file mode 100644 index 0000000..4e88aaa --- /dev/null +++ b/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/libs/networks/slim_nets/resnet_v2.py b/libs/networks/slim_nets/resnet_v2.py new file mode 100644 index 0000000..20b6e42 --- /dev/null +++ b/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/libs/networks/slim_nets/resnet_v2_test.py b/libs/networks/slim_nets/resnet_v2_test.py new file mode 100644 index 0000000..e715577 --- /dev/null +++ b/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/libs/networks/slim_nets/vgg.py b/libs/networks/slim_nets/vgg.py new file mode 100644 index 0000000..26fe59b --- /dev/null +++ b/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/libs/networks/slim_nets/vgg_test.py b/libs/networks/slim_nets/vgg_test.py new file mode 100644 index 0000000..691933c --- /dev/null +++ b/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/libs/networks/test_images/000013.jpg b/libs/networks/test_images/000013.jpg new file mode 100644 index 0000000000000000000000000000000000000000..893645b33eee875c91ac6c6958d4f9d33dd87b4f GIT binary patch literal 133840 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

UO}Eb1ENSqh`=`A`yaS#bx% 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 literal 0 HcmV?d00001 diff --git a/libs/networks/test_images/000018.jpg b/libs/networks/test_images/000018.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e76c295f2262cbb09ab748d2a6dc587d79f87fa3 GIT binary patch literal 52801 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�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

    qrUd<*ctA*)d-D1ihnuE5 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 gB3}$^4i5SS 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 E4~R;&3IG5A literal 0 HcmV?d00001 diff --git a/libs/networks/xception.bak.py b/libs/networks/xception.bak.py new file mode 100644 index 0000000..172eaf9 --- /dev/null +++ b/libs/networks/xception.bak.py @@ -0,0 +1,219 @@ +import tensorflow as tf + +USE_FUSED_BN = True +BN_EPSILON = 0.001 +BN_MOMENTUM = 0.99 + + +def reduced_kernel_size_for_small_input(input_tensor, 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 relu_separable_bn_block(inputs, filters, name_prefix, is_training, data_format): + bn_axis = -1 if data_format == 'channels_last' else 1 + inputs = tf.nn.relu(inputs, name=name_prefix + '_act') + + inputs = tf.layers.separable_conv2d(inputs, filters, (3, 3), + strides=(1, 1), padding='same', + data_format=data_format, + activation=None, use_bias=False, + depthwise_initializer=tf.contrib.layers.xavier_initializer(), + pointwise_initializer=tf.contrib.layers.xavier_initializer(), + bias_initializer=tf.zeros_initializer(), + name=name_prefix, reuse=None) + inputs = tf.layers.batch_normalization(inputs, momentum=BN_MOMENTUM, name=name_prefix + '_bn', axis=bn_axis, + epsilon=BN_EPSILON, training=is_training, reuse=None, fused=USE_FUSED_BN) + return inputs + + +def XceptionModel(input_image, num_classes, is_training = False, data_format='channels_last'): + bn_axis = -1 if data_format == 'channels_last' else 1 + # Entry Flow + inputs = tf.layers.conv2d(input_image, 32, (3, 3), use_bias=False, name='block1_conv1', strides=(2, 2), + padding='valid', data_format=data_format, activation=None, + kernel_initializer=tf.contrib.layers.xavier_initializer(), + bias_initializer=tf.zeros_initializer()) + inputs = tf.layers.batch_normalization(inputs, momentum=BN_MOMENTUM, name='block1_conv1_bn', axis=bn_axis, + epsilon=BN_EPSILON, training=is_training, reuse=None, fused=USE_FUSED_BN) + inputs = tf.nn.relu(inputs, name='block1_conv1_act') + + inputs = tf.layers.conv2d(inputs, 64, (3, 3), use_bias=False, name='block1_conv2', strides=(1, 1), + padding='valid', data_format=data_format, activation=None, + kernel_initializer=tf.contrib.layers.xavier_initializer(), + bias_initializer=tf.zeros_initializer()) + inputs = tf.layers.batch_normalization(inputs, momentum=BN_MOMENTUM, name='block1_conv2_bn', axis=bn_axis, + epsilon=BN_EPSILON, training=is_training, reuse=None, fused=USE_FUSED_BN) + inputs = tf.nn.relu(inputs, name='block1_conv2_act') + + residual = tf.layers.conv2d(inputs, 128, (1, 1), use_bias=False, name='conv2d_1', strides=(2, 2), + padding='same', data_format=data_format, activation=None, + kernel_initializer=tf.contrib.layers.xavier_initializer(), + bias_initializer=tf.zeros_initializer()) + residual = tf.layers.batch_normalization(residual, momentum=BN_MOMENTUM, name='batch_normalization_1', axis=bn_axis, + epsilon=BN_EPSILON, training=is_training, reuse=None, fused=USE_FUSED_BN) + + inputs = tf.layers.separable_conv2d(inputs, 128, (3, 3), + strides=(1, 1), padding='same', + data_format=data_format, + activation=None, use_bias=False, + depthwise_initializer=tf.contrib.layers.xavier_initializer(), + pointwise_initializer=tf.contrib.layers.xavier_initializer(), + bias_initializer=tf.zeros_initializer(), + name='block2_sepconv1', reuse=None) + inputs = tf.layers.batch_normalization(inputs, momentum=BN_MOMENTUM, name='block2_sepconv1_bn', axis=bn_axis, + epsilon=BN_EPSILON, training=is_training, reuse=None, fused=USE_FUSED_BN) + + inputs = relu_separable_bn_block(inputs, 128, 'block2_sepconv2', is_training, data_format) + + inputs = tf.layers.max_pooling2d(inputs, pool_size=(3, 3), strides=(2, 2), + padding='same', data_format=data_format, + name='block2_pool') + + inputs = tf.add(inputs, residual, name='residual_add_0') + residual = tf.layers.conv2d(inputs, 256, (1, 1), use_bias=False, name='conv2d_2', strides=(2, 2), + padding='same', data_format=data_format, activation=None, + kernel_initializer=tf.contrib.layers.xavier_initializer(), + bias_initializer=tf.zeros_initializer()) + residual = tf.layers.batch_normalization(residual, momentum=BN_MOMENTUM, name='batch_normalization_2', axis=bn_axis, + epsilon=BN_EPSILON, training=is_training, reuse=None, fused=USE_FUSED_BN) + + inputs = relu_separable_bn_block(inputs, 256, 'block3_sepconv1', is_training, data_format) + inputs = relu_separable_bn_block(inputs, 256, 'block3_sepconv2', is_training, data_format) + + inputs = tf.layers.max_pooling2d(inputs, pool_size=(3, 3), strides=(2, 2), + padding='same', data_format=data_format, + name='block3_pool') + inputs = tf.add(inputs, residual, name='residual_add_1') + + residual = tf.layers.conv2d(inputs, 728, (1, 1), use_bias=False, name='conv2d_3', strides=(2, 2), + padding='same', data_format=data_format, activation=None, + kernel_initializer=tf.contrib.layers.xavier_initializer(), + bias_initializer=tf.zeros_initializer()) + residual = tf.layers.batch_normalization(residual, momentum=BN_MOMENTUM, name='batch_normalization_3', axis=bn_axis, + epsilon=BN_EPSILON, training=is_training, reuse=None, fused=USE_FUSED_BN) + + inputs = relu_separable_bn_block(inputs, 728, 'block4_sepconv1', is_training, data_format) + inputs = relu_separable_bn_block(inputs, 728, 'block4_sepconv2', is_training, data_format) + + inputs = tf.layers.max_pooling2d(inputs, pool_size=(3, 3), strides=(2, 2), + padding='same', data_format=data_format, + name='block4_pool') + inputs = tf.add(inputs, residual, name='residual_add_2') + # Middle Flow + for index in range(8): + residual = inputs + prefix = 'block' + str(index + 5) + + inputs = relu_separable_bn_block(inputs, 728, prefix + '_sepconv1', is_training, data_format) + inputs = relu_separable_bn_block(inputs, 728, prefix + '_sepconv2', is_training, data_format) + inputs = relu_separable_bn_block(inputs, 728, prefix + '_sepconv3', is_training, data_format) + inputs = tf.add(inputs, residual, name=prefix + '_residual_add') + # Exit Flow + residual = tf.layers.conv2d(inputs, 1024, (1, 1), use_bias=False, name='conv2d_4', strides=(2, 2), + padding='same', data_format=data_format, activation=None, + kernel_initializer=tf.contrib.layers.xavier_initializer(), + bias_initializer=tf.zeros_initializer()) + residual = tf.layers.batch_normalization(residual, momentum=BN_MOMENTUM, name='batch_normalization_4', axis=bn_axis, + epsilon=BN_EPSILON, training=is_training, reuse=None, fused=USE_FUSED_BN) + + inputs = relu_separable_bn_block(inputs, 728, 'block13_sepconv1', is_training, data_format) + inputs = relu_separable_bn_block(inputs, 1024, 'block13_sepconv2', is_training, data_format) + + inputs = tf.layers.max_pooling2d(inputs, pool_size=(3, 3), strides=(2, 2), + padding='same', data_format=data_format, + name='block13_pool') + inputs = tf.add(inputs, residual, name='residual_add_3') + + inputs = tf.layers.separable_conv2d(inputs, 1536, (3, 3), + strides=(1, 1), padding='same', + data_format=data_format, + activation=None, use_bias=False, + depthwise_initializer=tf.contrib.layers.xavier_initializer(), + pointwise_initializer=tf.contrib.layers.xavier_initializer(), + bias_initializer=tf.zeros_initializer(), + name='block14_sepconv1', reuse=None) + inputs = tf.layers.batch_normalization(inputs, momentum=BN_MOMENTUM, name='block14_sepconv1_bn', axis=bn_axis, + epsilon=BN_EPSILON, training=is_training, reuse=None, fused=USE_FUSED_BN) + inputs = tf.nn.relu(inputs, name='block14_sepconv1_act') + + inputs = tf.layers.separable_conv2d(inputs, 2048, (3, 3), + strides=(1, 1), padding='same', + data_format=data_format, + activation=None, use_bias=False, + depthwise_initializer=tf.contrib.layers.xavier_initializer(), + pointwise_initializer=tf.contrib.layers.xavier_initializer(), + bias_initializer=tf.zeros_initializer(), + name='block14_sepconv2', reuse=None) + inputs = tf.layers.batch_normalization(inputs, momentum=BN_MOMENTUM, name='block14_sepconv2_bn', axis=bn_axis, + epsilon=BN_EPSILON, training=is_training, reuse=None, fused=USE_FUSED_BN) + inputs = tf.nn.relu(inputs, name='block14_sepconv2_act') + + if data_format == 'channels_first': + channels_last_inputs = tf.transpose(inputs, [0, 2, 3, 1]) + else: + channels_last_inputs = inputs + + inputs = tf.layers.average_pooling2d(inputs, pool_size = reduced_kernel_size_for_small_input(channels_last_inputs, [10, 10]), strides = 1, padding='valid', data_format=data_format, name='avg_pool') + + if data_format == 'channels_first': + inputs = tf.squeeze(inputs, axis=[2, 3]) + else: + inputs = tf.squeeze(inputs, axis=[1, 2]) + + outputs = tf.layers.dense(inputs, num_classes, + activation=tf.nn.softmax, use_bias=True, + kernel_initializer=tf.contrib.layers.xavier_initializer(), + bias_initializer=tf.zeros_initializer(), + name='dense', reuse=None) + + return outputs + + +if __name__ == '__main__': + '''model test samples + ''' + import numpy as np + # from tensorflow.python.keras._impl.keras.applications.imagenet_utils import decode_predictions # pylint: disable=unused-import + import scipy + import tensorflow.contrib.slim as slim + + tf.reset_default_graph() + + input_image = tf.placeholder(tf.float32, shape = (None, 299, 299, 3), name = 'input_placeholder') + outputs = XceptionModel(input_image, 1000, is_training = True, data_format='channels_last') + + saver = tf.train.Saver() + + with tf.Session() as sess: + init = tf.global_variables_initializer() + sess.run(init) + + model_variables = tf.trainable_variables() + print(model_variables) + + saver.restore(sess, "/data/RetinaNet_TF/data/pretrained_weights/xception_tf_model/xception_model.ckpt") + + image_file = ['test_images/000013.jpg', 'test_images/000018.jpg', 'test_images/000031.jpg', 'test_images/000038.jpg', 'test_images/000045.jpg'] + image_array = [] + for file in image_file: + np_image = scipy.misc.imread(file, mode='RGB') + np_image = scipy.misc.imresize(np_image, (299, 299)) + np_image = np.expand_dims(np_image, axis=0).astype(np.float32) + image_array.append(np_image) + np_image = np.concatenate(image_array, axis=0) + np_image /= 127.5 + np_image -= 1. + #np_image = np.transpose(np_image, (0, 3, 1, 2)) + predict = sess.run(outputs, feed_dict = {input_image : np_image}) + #print(predict) + print(np.argmax(predict)) + # print('Predicted:', decode_predictions(predict, 1)) + + diff --git a/libs/networks/xception.py b/libs/networks/xception.py new file mode 100644 index 0000000..d74a962 --- /dev/null +++ b/libs/networks/xception.py @@ -0,0 +1,265 @@ +import tensorflow as tf +import tensorflow.contrib.slim as slim + +from libs.configs import cfgs + +USE_FUSED_BN = True +BN_EPSILON = 0.001 +BN_MOMENTUM = 0.99 + + +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 reduced_kernel_size_for_small_input(input_tensor, 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 relu_separable_bn_block(inputs, filters, name_prefix, is_training, data_format, has_bn=False): + bn_axis = -1 if data_format == 'channels_last' else 1 + + inputs = tf.nn.relu(inputs, name=name_prefix + '_act') + inputs = tf.layers.separable_conv2d(inputs, filters, (3, 3), + strides=(1, 1), padding='same', + data_format=data_format, + activation=None, use_bias=False, + depthwise_initializer=tf.contrib.layers.xavier_initializer(), + pointwise_initializer=tf.contrib.layers.xavier_initializer(), + bias_initializer=tf.zeros_initializer(), + name=name_prefix, reuse=None) + # inputs = tf.layers.batch_normalization(inputs, momentum=BN_MOMENTUM, name=name_prefix + '_bn', axis=bn_axis, + # epsilon=BN_EPSILON, training=has_bn, reuse=None, fused=USE_FUSED_BN) + return inputs + + +def XceptionModel(input_image, num_classes, is_training=False, has_bn=False, data_format='channels_last'): + feature_dict = {} + + bn_axis = -1 if data_format == 'channels_last' else 1 + # Entry Flow + inputs = tf.layers.conv2d(input_image, 32, (3, 3), use_bias=False, name='block1_conv1', strides=(2, 2), + padding='valid', data_format=data_format, activation=None, + kernel_initializer=tf.contrib.layers.xavier_initializer(), + bias_initializer=tf.zeros_initializer()) + # inputs = tf.layers.batch_normalization(inputs, momentum=BN_MOMENTUM, name='block1_conv1_bn', axis=bn_axis, + # epsilon=BN_EPSILON, training=has_bn, reuse=None, fused=USE_FUSED_BN) + inputs = tf.nn.relu(inputs, name='block1_conv1_act') + + inputs = tf.layers.conv2d(inputs, 64, (3, 3), use_bias=False, name='block1_conv2', strides=(1, 1), + padding='valid', data_format=data_format, activation=None, + kernel_initializer=tf.contrib.layers.xavier_initializer(), + bias_initializer=tf.zeros_initializer()) + # inputs = tf.layers.batch_normalization(inputs, momentum=BN_MOMENTUM, name='block1_conv2_bn', axis=bn_axis, + # epsilon=BN_EPSILON, training=has_bn, reuse=None, fused=USE_FUSED_BN) + inputs = tf.nn.relu(inputs, name='block1_conv2_act') + + residual = tf.layers.conv2d(inputs, 128, (1, 1), use_bias=False, name='conv2d_1', strides=(2, 2), + padding='same', data_format=data_format, activation=None, + kernel_initializer=tf.contrib.layers.xavier_initializer(), + bias_initializer=tf.zeros_initializer()) + # residual = tf.layers.batch_normalization(residual, momentum=BN_MOMENTUM, name='batch_normalization_1', axis=bn_axis, + # epsilon=BN_EPSILON, training=has_bn, reuse=None, fused=USE_FUSED_BN) + + inputs = tf.layers.separable_conv2d(inputs, 128, (3, 3), + strides=(1, 1), padding='same', + data_format=data_format, + activation=None, use_bias=False, + depthwise_initializer=tf.contrib.layers.xavier_initializer(), + pointwise_initializer=tf.contrib.layers.xavier_initializer(), + bias_initializer=tf.zeros_initializer(), + name='block2_sepconv1', reuse=None) + # inputs = tf.layers.batch_normalization(inputs, momentum=BN_MOMENTUM, name='block2_sepconv1_bn', axis=bn_axis, + # epsilon=BN_EPSILON, training=has_bn, reuse=None, fused=USE_FUSED_BN) + + inputs = relu_separable_bn_block(inputs, 128, 'block2_sepconv2', is_training, data_format, has_bn) + + inputs = tf.layers.max_pooling2d(inputs, pool_size=(3, 3), strides=(2, 2), + padding='same', data_format=data_format, + name='block2_pool') + + feature_dict['C2'] = inputs + + inputs = tf.add(inputs, residual, name='residual_add_0') + residual = tf.layers.conv2d(inputs, 256, (1, 1), use_bias=False, name='conv2d_2', strides=(2, 2), + padding='same', data_format=data_format, activation=None, + kernel_initializer=tf.contrib.layers.xavier_initializer(), + bias_initializer=tf.zeros_initializer()) + # residual = tf.layers.batch_normalization(residual, momentum=BN_MOMENTUM, name='batch_normalization_2', axis=bn_axis, + # epsilon=BN_EPSILON, training=has_bn, reuse=None, fused=USE_FUSED_BN) + + inputs = relu_separable_bn_block(inputs, 256, 'block3_sepconv1', is_training, data_format, has_bn) + inputs = relu_separable_bn_block(inputs, 256, 'block3_sepconv2', is_training, data_format, has_bn) + + inputs = tf.layers.max_pooling2d(inputs, pool_size=(3, 3), strides=(2, 2), + padding='same', data_format=data_format, + name='block3_pool') + inputs = tf.add(inputs, residual, name='residual_add_1') + + feature_dict['C3'] = inputs + + residual = tf.layers.conv2d(inputs, 728, (1, 1), use_bias=False, name='conv2d_3', strides=(2, 2), + padding='same', data_format=data_format, activation=None, + kernel_initializer=tf.contrib.layers.xavier_initializer(), + bias_initializer=tf.zeros_initializer()) + # residual = tf.layers.batch_normalization(residual, momentum=BN_MOMENTUM, name='batch_normalization_3', axis=bn_axis, + # epsilon=BN_EPSILON, training=has_bn, reuse=None, fused=USE_FUSED_BN) + + inputs = relu_separable_bn_block(inputs, 728, 'block4_sepconv1', is_training, data_format, has_bn) + inputs = relu_separable_bn_block(inputs, 728, 'block4_sepconv2', is_training, data_format, has_bn) + + inputs = tf.layers.max_pooling2d(inputs, pool_size=(3, 3), strides=(2, 2), + padding='same', data_format=data_format, + name='block4_pool') + inputs = tf.add(inputs, residual, name='residual_add_2') + + feature_dict['C4'] = inputs + + # Middle Flow + for index in range(8): + residual = inputs + prefix = 'block' + str(index + 5) + + inputs = relu_separable_bn_block(inputs, 728, prefix + '_sepconv1', is_training, data_format, has_bn) + inputs = relu_separable_bn_block(inputs, 728, prefix + '_sepconv2', is_training, data_format, has_bn) + inputs = relu_separable_bn_block(inputs, 728, prefix + '_sepconv3', is_training, data_format, has_bn) + inputs = tf.add(inputs, residual, name=prefix + '_residual_add') + # Exit Flow + residual = tf.layers.conv2d(inputs, 1024, (1, 1), use_bias=False, name='conv2d_4', strides=(2, 2), + padding='same', data_format=data_format, activation=None, + kernel_initializer=tf.contrib.layers.xavier_initializer(), + bias_initializer=tf.zeros_initializer()) + # residual = tf.layers.batch_normalization(residual, momentum=BN_MOMENTUM, name='batch_normalization_4', axis=bn_axis, + # epsilon=BN_EPSILON, training=has_bn, reuse=None, fused=USE_FUSED_BN) + + inputs = relu_separable_bn_block(inputs, 728, 'block13_sepconv1', is_training, data_format, has_bn) + inputs = relu_separable_bn_block(inputs, 1024, 'block13_sepconv2', is_training, data_format, has_bn) + + inputs = tf.layers.max_pooling2d(inputs, pool_size=(3, 3), strides=(2, 2), + padding='same', data_format=data_format, + name='block13_pool') + inputs = tf.add(inputs, residual, name='residual_add_3') + + feature_dict['C5'] = inputs + + # inputs = tf.layers.separable_conv2d(inputs, 1536, (3, 3), + # strides=(1, 1), padding='same', + # data_format=data_format, + # activation=None, use_bias=False, + # depthwise_initializer=tf.contrib.layers.xavier_initializer(), + # pointwise_initializer=tf.contrib.layers.xavier_initializer(), + # bias_initializer=tf.zeros_initializer(), + # name='block14_sepconv1', reuse=None) + # inputs = tf.layers.batch_normalization(inputs, momentum=BN_MOMENTUM, name='block14_sepconv1_bn', axis=bn_axis, + # epsilon=BN_EPSILON, training=has_bn, reuse=None, fused=USE_FUSED_BN) + # inputs = tf.nn.relu(inputs, name='block14_sepconv1_act') + # + # inputs = tf.layers.separable_conv2d(inputs, 2048, (3, 3), + # strides=(1, 1), padding='same', + # data_format=data_format, + # activation=None, use_bias=False, + # depthwise_initializer=tf.contrib.layers.xavier_initializer(), + # pointwise_initializer=tf.contrib.layers.xavier_initializer(), + # bias_initializer=tf.zeros_initializer(), + # name='block14_sepconv2', reuse=None) + # inputs = tf.layers.batch_normalization(inputs, momentum=BN_MOMENTUM, name='block14_sepconv2_bn', axis=bn_axis, + # epsilon=BN_EPSILON, training=has_bn, reuse=None, fused=USE_FUSED_BN) + # inputs = tf.nn.relu(inputs, name='block14_sepconv2_act') + # + # if data_format == 'channels_first': + # channels_last_inputs = tf.transpose(inputs, [0, 2, 3, 1]) + # else: + # channels_last_inputs = inputs + # + # inputs = tf.layers.average_pooling2d(inputs, pool_size=reduced_kernel_size_for_small_input(channels_last_inputs, [10, 10]), strides = 1, padding='valid', data_format=data_format, name='avg_pool') + # + # if data_format == 'channels_first': + # inputs = tf.squeeze(inputs, axis=[2, 3]) + # else: + # inputs = tf.squeeze(inputs, axis=[1, 2]) + # + # outputs = tf.layers.dense(inputs, num_classes, + # activation=tf.nn.softmax, use_bias=True, + # kernel_initializer=tf.contrib.layers.xavier_initializer(), + # bias_initializer=tf.zeros_initializer(), + # name='dense', reuse=None) + + return feature_dict + + +def xception_base(input_image, is_training=True): + feature_dict = XceptionModel(input_image, 1000, is_training=is_training, has_bn=False, data_format='channels_last') + + 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(feature_dict['C5'], + num_outputs=256, + kernel_size=[1, 1], + stride=1, scope='build_P5') + + pyramid_dict['P5'] = P5 + + for level in range(4, 2, -1): # build [P4, P3] + + 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(5, 2, -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) + + p6 = slim.conv2d(pyramid_dict['P5'] if cfgs.USE_P5 else feature_dict['C5'], + num_outputs=256, kernel_size=[3, 3], padding="SAME", + stride=2, scope='p6_conv') + pyramid_dict['P6'] = p6 + + p7 = tf.nn.relu(p6, name='p6_relu') + + p7 = slim.conv2d(p7, + num_outputs=256, kernel_size=[3, 3], padding="SAME", + stride=2, scope='p7_conv') + + pyramid_dict['P7'] = p7 + + # for level in range(7, 1, -1): + # add_heatmap(pyramid_dict['P%d' % level], name='Layer%d/P%d_heat' % (level, level)) + + return pyramid_dict + diff --git a/libs/setup.py b/libs/setup.py new file mode 100644 index 0000000..603cac4 --- /dev/null +++ b/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/libs/val_libs/__init__.py b/libs/val_libs/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/libs/val_libs/voc_eval.py b/libs/val_libs/voc_eval.py new file mode 100644 index 0000000..d0f52bb --- /dev/null +++ b/libs/val_libs/voc_eval.py @@ -0,0 +1,263 @@ +# -------------------------------------------------------- +# 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 + +from libs.label_name_dict.label_dict import NAME_LABEL_MAP +from libs.configs import cfgs +from help_utils.tools import mkdir + +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) + + 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, + use_07_metric=cfgs.USE_07_METRIC) + AP_list += [AP] + print("cls : {}|| Recall: {} || Precison: {}|| AP: {}".format(cls, recall[-1], precision[-1], AP)) + # plt.plot(recall, precision, label=cls, color=color_list[index]) + # plt.legend(loc='upper right') + # print(10*"__") + # plt.show() + # plt.savefig(cfgs.VERSION+'.jpg') + 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/output/trained_weights/README.md b/output/trained_weights/README.md new file mode 100644 index 0000000..0f522e3 --- /dev/null +++ b/output/trained_weights/README.md @@ -0,0 +1 @@ +Please download [trained model](https://github.com/DetectionTeamUCAS/Models/RetinaNet_Tensorflow) by this project, then put it here. \ No newline at end of file diff --git a/tools/__init__.py b/tools/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tools/demos/000058.jpg b/tools/demos/000058.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7121098b473dc500f71e75b9b4e47d8c406640cc GIT binary patch literal 129047 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 S)ZlgZqKYVYPeydD5C7SYTD7YH literal 0 HcmV?d00001 diff --git a/tools/demos/000108.jpg b/tools/demos/000108.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d5de1eb1df3983a0b48d5e936d55928db36b7945 GIT binary patch literal 75282 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%0D@d2RYyiaFN}2CKD>S9CnuTO3GkqnZag7 zVZ3cnsLth7w&qn{fMGt(;z{g|u|0~Usdm?`a}t-3v|y<6(RgLR1#$ryAfK3uWrvJB zT(=VFcRme!%TF@y$`@;~40GERSj@$gZdC?SHkJo!oRAMOFK=1iN!@+ml~%P!EqkbH zRyH=e*N2xxvbslK%Tyv(lr23psTtEmeH0 z%S|z&VJJIEC9~%^3M5uQ$`O>7Jb~O;cp^5BZf_UI;_nXlY3?kqBM@C$+-hE2leA$~CM;NmQV3=T1eIfffn5)U^k$0A z?$gBnH?xb*)gn}a($##i42sR=yR$HoLV%*N2X@j(0f?+0gQ*^y73Q6DWp!zQB=Z@3 z{r2UHftSf;RsjN$g(Qu{oQ}Od7wES(_m@{z@x^sLoUd-r2$wgg+k&8Cq0VCiJG&?c z2c0QGcK2QG^}7C;;ZC8Qd!*=oB=HWhY2p1mT|p+HFO)29BZ(i+g`*20z)&2;w2&77 zbs>&s@aBVeeG8om&_uIYwUvd9<HYL+!Z^RZxvNKi`T;Z$wls~&*WZ8`T^U-*Alu^TO||QTH zwiIqGLWNSwa#$@xsQf0x4fNW7euBLEIfX(;l>@=4oWdK8@|zs$kZejJM%mC^M{Ew#9eY+;ox@|^wPz~M&f*U+yt z?+j0NnsoMtD6S-f?N*3XGfa090%L52*oHVG1gP#rE#li9KIRV$SZj@_LYE_b<+LSW z05eL_JfZhIg9_XX?%?1IHZ?G`>(g}>mhSie05TLQxhBSVcftAvwcH0!xspec2_Tui zMSbn^%H$(vP!xqJl{iv30Yz*_@T>c7_U*J!3&(FY-HCOx#@MVjER7+NazF(DA^RTu zfmv1`5wCnb9+=)AvYzHC3q|%wok5t%xT?s-8CWP{!EiVX+lNq*+UqguiKuvVeW4u6 zOmSQnF)3+T!-m1Y8@MMqzyszu%MXXADqOLBleV9A#=V?0Q8lz{EduvgOBsB4t7jFB zyq8xmY)qnP<8@V!CpcnARu~Js1B}*&r=fUpHD|kv#L){`ghLR>0fJK-Gf0XFW@7K2 zIt-}fgIxarhkQq^Y11lex|183?!gS!C`97iugU>Z%OHhi3_#io0y<`sPrK3ISpLR} zOIel;Ks-%4Vc*JN(XQnHh9QYy1_%mR@mop}r$^sczt8osqswiXV%7}{`&t;I@n)fU zJa&(!&vg5qIpYz@A&NC!s-^H7a~;gg#NaJa(tH_jHHf&@wTUlHmX`MuMIvpIJEFLW zP%|*{$z*0?4i0!=0jk<&nJxCaFNZBP^s-xv!6u`q-76SkRZ`;tNOg8QcCuvUQB_DR zO?%;gX(pL}tLoNr7-e*6?&2Gf6%}ymxe>4%&f*BmU;%-*Crb}1YntAg>G+YPp4ysL z-wy7zJ6L=>r+B_SChg>kd9LA6=EoN1V1d~fF6;of1TN+|1cDP%@Sgtw3&nYB;-^Nv zw3up5ac{6oa2Zuu2pP!$vo20cZX-D+hKsIvb}tqU6JNczwYgm_?-If}TOmZ7kem__ zk+iN3SJURLHP&=Epn}Pr?{47}PSQqM+BYO&93lC(jGUjCmd{KYYY#!u(JT5UTq90f zJ$*_(A-B-=D+uqcrkd(WBU^VbBM;t&3{}YBuJQ7KrB#_uHt|er{X*YV)9-ZXZEbBM zfGW>m-eJSc902SF@;C0s%6?*`VTEkzo*s`}FKMOQS>NBzVMv4*42v7EVi;}0vtSk= z;41QY%}b_e3#-Qk%j;I}2A`_5R?sv`CAUTh%DI1)3hXY#ZVaxyIIhT1bAtDhYq#oO zvAf+^=j?nbqS;IT00~Zuqq-&IK_lD1puCC$tCVoSYzPbOBa?+44O7wl5u@qatKLIx z=3LxrXl?N$NwQ=>9&!SPaHt|+oeMhj1)96~?zM{@4lg%TYnWeXyOz|Z*~*gNIA8!O z#IljY1vuT(x!b=P>Y8oml`*!3a9k}HUBF7BWf zuN94`Hr796Kop^MK~4Tpii$QbGfmU=~wm2j}fE7?tU653!yDkKr8DvH3e1bv0U z-LwTGCAge;A5qnOJT*mu?dG?(2{5+3%3Vo21Pls{sgPt400UucDH$qIt0=UR+TrZu z9aA&yHArF88arDf1QyXXw%a}7V|8uICU*_8GJ}>N3loM9jyG*ZX6)OP@N#geLB_17 zQS#r?<}#-^$z9mp@C@3=j&&-ny9$ZoEf$cmsz8I4%T32rhQ3ZUSDC?IE~+7^sN zcNg;OklZX9+;N+P+A^`0XOM*;fw1mUpzd@EF|?X(--+Px#*b@zqrIH4T|n15gQ42% zcqJ&Pc9V<+3c~|w&N3?}N%5b9{{Xbj-POD?NoI~9Hb}zOR|=B|#HxN$5%IvaQL=ZE$+ck4(DZOCmhJ2M7xH5P{fi&Y3SESPO?kay0nt+;KL=< zf;Mf;S%E;IzEloLz|Iwl;BDhV$5^qq6KG%AvZb`50is26#TCJ30PkV}3g9W*fVdzM zaavQS?OR;VG4wQzN>O{WJ5=!{rL1e9_=*cTqG9FFC9^RGJZETj7-F~wIN-kSL8|vQ zS{1H^V-1?7zht|hv@L2P`#gU$0P3eKN;8eTsZ+FYGew@Qr?lR8n2^S2FyCIL*0`Sv z%!gV?LoDnHsTKZQxkeBem42V#IC)f(hIR8RMqA&@`=YRbLTHtjlcaHOBa@U9e>g zxgfVV1=T?$k^oW1N|rwjd|R*S*V+^sQ8HXae$Q_dWfm}`$lJg>l!8IP<7g|>Im6i0 zsN>3!oKllz4-@=7@hyW-cAg?=;kK4LOQe~aLX8MjW*@|yxC&3*Do#knXX^SMv*E2# zH94=NmMv<{Z*@y|m6~}#9$6!3!Z;{Nayi@y1TiCS*T7aj8@z%Ye_Xt{R)EQK{*k}! z0d3fMcy1ID3j@vyk=3dGB-HIz6?-_EYl!y!mRXx9A9>9p^+%*fI-?-F0w!*=#o_jeZ%qDt2e3&A)cmoj|Cum;vq{3xxSHa`Y7>cCct@8aIVuQPIN&C*n6=mRr@dlwKjnH`2l01OSd3>X!s*nB#r*Ob7b+Er98(vmP(6NX?g0|T5D@tli2Ti) zfApPOS&rlPi*2XcEwaBNC4IYs=k9~t4!!HD__s92#ojN7%G+({xAGTv5&Yxs`hFBq zUiJt6Mb$k&%-UbVUq8%`!J3w%7lwR29C!07{{Uo0Hmsx%zTWju;Wg#nq2Vi^x7|rU z&Wro!EyFwHbJ+LwqKcV+8G0|t89(A9g!p%>YO&g1$sVV0t-DJ3mSzW-(4PIzC)T|d z#z_sm`-C{;a^e4Zq6jQJKSbYBgLuqbwzX`3a?!F*g*<8SqL-scP)QSrI z_3U`A7V6&K4 zR$~4?xQD_3f5N^?%zpXxhgX;Qn0XO!Pf{xv$}DB$u`@ zBr`m*Gs_Z%WP~ z>Ux?!FI-Qg{8-cNw7H(zF{j?Jj@^nbe1pyhdMK=G{{Xo!U(uL<%ccExDfj~N?FEc! zbs$~V-zamBzmMg`Sh)FqAZXBz6aEq@Q()<|TO15}4#J8n$Ho5u6@1E{!yi+Bz|QvJ zYQIGJu z{U=MemgD!0{{Rz_x%odVEw`_x20bt;ZxDfL@e4$=wH{n8d40Ml{#8FTU56A=T^N6Z z=lUY(eUrV=tu0r^@X9Tt3~p!31Q|J=ML(G1>BVdK$)BgaMUwOn>!wtrVX0ybuHzy9c{w5v$xT;rxPp4~walA(%Xv6cg`G=9{ zXri{E{_h`Fb4TGDrF^?A*NA@Car>e7f7Zv_rC0b-scJXvs@Y#(%`_>j+D4H}DP>e* z0Z<9R1aL=sD5|IS%AxQw-oDJ=2z)Ti#F1i*2|vWzsZxHVa8Gf?bw3m*p3v)d*0Vfu zrHo3E#>6VF(ZBjKEI^Y4?aR zH%Pd(q49o)|yEThTr2oheGupT1@bCe zJEo2H}u%&gRdqFrrQA(BJk544viPd3B%g#6sG&p!R=qNn~| zKU1P#8HsSJ+SF5(1=itkTe4lA?ghJlMDgsG^G73GlNO@vl>f_{Ti<-Z9r>wwdEp@lEc< sMj$Wmr0I^8nc{dLO-j(DC_mF6=%e_pn78J6KD1Fy{{RwaEl-61+5d=0b^rhX literal 0 HcmV?d00001 diff --git a/tools/demos/000449.jpg b/tools/demos/000449.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3c5c1c4e63dad681f87468ca029c242fc33afb8d GIT binary patch literal 88727 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 literal 0 HcmV?d00001 diff --git a/tools/demos/000611.jpg b/tools/demos/000611.jpg new file mode 100644 index 0000000000000000000000000000000000000000..073a1e6c327698ef8d5a2658a3d53bc915354767 GIT binary patch literal 94677 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 g`UN2DEee&a&pI_u5@{Tlz=h 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

    %X;4sA-yPul=PVPd`qGvXI28hh!vz0Qr>jmCrTE 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 bNu8lahX8>S&^hwXwW@6o3EODetz5 literal 0 HcmV?d00001 diff --git a/tools/demos/004640.jpg b/tools/demos/004640.jpg new file mode 100644 index 0000000000000000000000000000000000000000..40848c2fedc8f31a62fb0c7f70dd54eb6e2221c2 GIT binary patch literal 119476 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

    ;n3Tz=BtA^3lDqkKNn?FG&Ei1mgrskXR2M0YVl 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 cfgs.VIS_SCORE + show_scores = detected_scores[show_indices] + show_boxes = detected_boxes[show_indices] + show_categories = detected_categories[show_indices] + + draw_img = np.squeeze(resized_img, 0) + if cfgs.NET_NAME in ['resnet152_v1d', 'resnet101_v1d', 'resnet50_v1d']: + draw_img = (draw_img * np.array(cfgs.PIXEL_STD) + np.array(cfgs.PIXEL_MEAN_)) * 255 + else: + draw_img = draw_img + np.array(cfgs.PIXEL_MEAN) + final_detections = draw_box_in_img.draw_boxes_with_label_and_scores(draw_img, + boxes=show_boxes, + labels=show_categories, + scores=show_scores, + in_graph=False) + 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) + + pbar.set_description("Eval image %s" % a_img_name) + + # 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'), 'w') + # pickle.dump(all_boxes, fw1) + return all_boxes + + +def eval(num_imgs, eval_dir, annotation_dir, showbox): + + 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')) 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/VOCdevkit/VOC2007/JPEGImages', type=str) + parser.add_argument('--annotation_dir', dest='test_annotation_dir', + help='the dir save annotations', + default='/data/VOCdevkit/VOC2007/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='0', type=str) + parser.add_argument('--eval_num', dest='eval_num', + help='the num of eval imgs', + default=np.inf, 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(args.eval_num, # 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/tools/eval_coco.py b/tools/eval_coco.py new file mode 100644 index 0000000..b46385f --- /dev/null +++ b/tools/eval_coco.py @@ -0,0 +1,222 @@ +# -*- 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 cv2 +import numpy as np +import json +from tqdm import tqdm +sys.path.append("../") + +from data.io.image_preprocess import short_side_resize_for_inference_data +from libs.networks import build_whole_network +from libs.box_utils import draw_box_in_img +import argparse +from help_utils import tools +from libs.label_name_dict.label_dict import * + +from data.lib_coco.PythonAPI.pycocotools.coco import COCO +from data.lib_coco.PythonAPI.pycocotools.cocoeval import COCOeval + + +def cocoval(detected_json, eval_json): + eval_gt = COCO(eval_json) + + eval_dt = eval_gt.loadRes(detected_json) + cocoEval = COCOeval(eval_gt, eval_dt, iouType='bbox') + + # cocoEval.params.imgIds = eval_gt.getImgIds() + cocoEval.evaluate() + cocoEval.accumulate() + cocoEval.summarize() + + +def eval_coco(det_net, real_test_img_list, 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) + if cfgs.NET_NAME in ['resnet152_v1d', 'resnet101_v1d', 'resnet50_v1d']: + img_batch = (img_batch / 255 - tf.constant(cfgs.PIXEL_MEAN_)) / tf.constant(cfgs.PIXEL_STD) + else: + 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 + + with tf.Session(config=config) as sess: + sess.run(init_op) + if not restorer is None: + restorer.restore(sess, restore_ckpt) + print('restore model') + + save_path = os.path.join('./eval_coco', cfgs.VERSION) + tools.mkdir(save_path) + fw_json_dt = open(os.path.join(save_path, 'coco_minival.json'), 'w') + coco_det = [] + + pbar = tqdm(real_test_img_list) + for a_img in pbar: + record = json.loads(a_img) + img_path = os.path.join('/data/COCO/val2017', record['fpath'].split('_')[-1]) + raw_img = cv2.imread(img_path) + # raw_img = cv2.imread(record['fpath']) + raw_h, raw_w = raw_img.shape[0], raw_img.shape[1] + + 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 + ) + + eval_indices = detected_scores >= 0.01 + detected_scores = detected_scores[eval_indices] + detected_boxes = detected_boxes[eval_indices] + detected_categories = detected_categories[eval_indices] + + if draw_imgs: + show_indices = detected_scores >= 0.3 + show_scores = detected_scores[show_indices] + show_boxes = detected_boxes[show_indices] + show_categories = detected_categories[show_indices] + + draw_img = np.squeeze(resized_img, 0) + + if cfgs.NET_NAME in ['resnet152_v1d', 'resnet101_v1d', 'resnet50_v1d']: + draw_img = (draw_img * np.array(cfgs.PIXEL_STD) + np.array(cfgs.PIXEL_MEAN_)) * 255 + else: + draw_img = draw_img + np.array(cfgs.PIXEL_MEAN) + final_detections = draw_box_in_img.draw_boxes_with_label_and_scores(draw_img, + boxes=show_boxes, + labels=show_categories, + scores=show_scores, + in_graph=False) + if not os.path.exists(cfgs.TEST_SAVE_PATH): + os.makedirs(cfgs.TEST_SAVE_PATH) + + cv2.imwrite(cfgs.TEST_SAVE_PATH + '/' + record['ID'], + 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])) + + # cost much time + for j, box in enumerate(boxes): + coco_det.append({'bbox': [float(box[0]), float(box[1]), float(box[2]), float(box[3])], + 'score': float(detected_scores[j]), 'image_id': int(record['ID'].split('.jpg')[0].split('_000000')[-1]), + 'category_id': int(classes_originID[LABEL_NAME_MAP[detected_categories[j]]])}) + + pbar.set_description("Eval image %s" % record['ID']) + + json.dump(coco_det, fw_json_dt) + fw_json_dt.close() + return os.path.join(save_path, 'coco_minival.json') + + +def eval(num_imgs, eval_data, eval_gt, showbox): + + with open(eval_data) as f: + test_img_list = f.readlines() + + if num_imgs == np.inf: + real_test_img_list = test_img_list + else: + real_test_img_list = test_img_list[: num_imgs] + + faster_rcnn = build_whole_network.DetectionNetwork(base_network_name=cfgs.NET_NAME, + is_training=False) + detected_json = eval_coco(det_net=faster_rcnn, real_test_img_list=real_test_img_list, draw_imgs=showbox) + + # save_path = os.path.join('./eval_coco', cfgs.VERSION) + # detected_json = os.path.join(save_path, 'coco_minival.json') + cocoval(detected_json, eval_gt) + + +def parse_args(): + + parser = argparse.ArgumentParser('evaluate the result with Pascal2007 stdand') + + parser.add_argument('--eval_data', dest='eval_data', + help='evaluate imgs dir ', + default='coco_minival2014.odgt', type=str) + parser.add_argument('--eval_gt', dest='eval_gt', + help='eval gt', + default='instances_minival2014.json', + type=str) + parser.add_argument('--showbox', dest='showbox', + help='whether show detecion results when evaluation', + default=True, type=bool) + parser.add_argument('--GPU', dest='GPU', + help='gpu id', + default='0', type=str) + parser.add_argument('--eval_num', dest='eval_num', + help='the num of eval imgs', + default=np.inf, 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(args.eval_num, # use np.inf to test all the imgs. use 10 to test 10 imgs. + # eval_data=args.eval_data, + # eval_gt=args.eval_gt, + # showbox=args.showbox) + + os.environ["CUDA_VISIBLE_DEVICES"] = '0' + eval(np.inf, # use np.inf to test all the imgs. use 10 to test 10 imgs. + eval_data='/data/COCO/coco_minival2014.odgt', + eval_gt='/data/COCO/instances_minival2014.json', + showbox=False) + + + + + + + + + + + + + + + + diff --git a/tools/eval_coco_multiprocessing.py b/tools/eval_coco_multiprocessing.py new file mode 100644 index 0000000..f567748 --- /dev/null +++ b/tools/eval_coco_multiprocessing.py @@ -0,0 +1,233 @@ +# -*- coding:utf-8 -*- + +from __future__ import absolute_import +from __future__ import print_function +from __future__ import division + +import os +import sys +import tensorflow as tf +import cv2 +import numpy as np +import json +import math +from tqdm import tqdm +from multiprocessing import Queue, Process +import argparse +sys.path.append("../") + +from data.io.image_preprocess import short_side_resize_for_inference_data +from libs.networks import build_whole_network +from help_utils import tools +from libs.label_name_dict.label_dict import * + +from data.lib_coco.PythonAPI.pycocotools.coco import COCO +from data.lib_coco.PythonAPI.pycocotools.cocoeval import COCOeval + + +def cocoval(detected_json, eval_json): + eval_gt = COCO(eval_json) + + eval_dt = eval_gt.loadRes(detected_json) + cocoEval = COCOeval(eval_gt, eval_dt, iouType='bbox') + + # cocoEval.params.imgIds = eval_gt.getImgIds() + cocoEval.evaluate() + cocoEval.accumulate() + cocoEval.summarize() + + +def worker(gpu_id, images, det_net, result_queue): + os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id) + # 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) + if cfgs.NET_NAME in ['resnet152_v1d', 'resnet101_v1d', 'resnet50_v1d']: + img_batch = (img_batch / 255 - tf.constant(cfgs.PIXEL_MEAN_)) / tf.constant(cfgs.PIXEL_STD) + else: + 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 + + with tf.Session(config=config) as sess: + sess.run(init_op) + if not restorer is None: + restorer.restore(sess, restore_ckpt) + print('restore model %d ...' % gpu_id) + for a_img in images: + record = json.loads(a_img) + img_path = os.path.join('/data/COCO/val2017', record['fpath'].split('_')[-1]) + raw_img = cv2.imread(img_path) + # raw_img = cv2.imread(record['fpath']) + raw_h, raw_w = raw_img.shape[0], raw_img.shape[1] + + 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]} + ) + + resized_h, resized_w = resized_img.shape[1], resized_img.shape[2] + scales = [raw_w / resized_w, raw_h / resized_h] + result_dict = {'scales': scales, 'boxes': detected_boxes, + 'scores': detected_scores, 'labels': detected_categories, + 'image_id': record['ID']} + result_queue.put_nowait(result_dict) + + +def eval_coco(det_net, real_test_img_list, gpu_ids): + + save_path = os.path.join('./eval_coco', cfgs.VERSION) + tools.mkdir(save_path) + fw_json_dt = open(os.path.join(save_path, 'coco_minival.json'), 'w') + coco_det = [] + + nr_records = len(real_test_img_list) + pbar = tqdm(total=nr_records) + gpu_num = len(gpu_ids.strip().split(',')) + + nr_image = math.ceil(nr_records / gpu_num) + result_queue = Queue(500) + procs = [] + + for i in range(gpu_num): + start = i * nr_image + end = min(start + nr_image, nr_records) + split_records = real_test_img_list[start:end] + proc = Process(target=worker, args=(i, split_records, det_net, result_queue)) + print('process:%d, start:%d, end:%d' % (i, start, end)) + proc.start() + procs.append(proc) + + for i in range(nr_records): + res = result_queue.get() + + xmin, ymin, xmax, ymax = res['boxes'][:, 0], res['boxes'][:, 1], \ + res['boxes'][:, 2], res['boxes'][:, 3] + + xmin = xmin * res['scales'][0] + xmax = xmax * res['scales'][0] + + ymin = ymin * res['scales'][1] + ymax = ymax * res['scales'][1] + + boxes = np.transpose(np.stack([xmin, ymin, xmax-xmin, ymax-ymin])) + + sort_scores = np.array(res['scores']) + sort_labels = np.array(res['labels']) + sort_boxes = np.array(boxes) + + # if len(res['scores']) > cfgs.MAXIMUM_DETECTIONS: + # sort_indx = np.argsort(np.array(res['scores']) * -1)[:cfgs.MAXIMUM_DETECTIONS] + # print(sort_indx) + # sort_scores = np.array(res['scores'])[sort_indx] + # sort_labels = np.array(res['labels'])[sort_indx] + # sort_boxes = np.array(boxes)[sort_indx] + + for j, box in enumerate(sort_boxes): + coco_det.append({'bbox': [float(box[0]), float(box[1]), float(box[2]), float(box[3])], + 'score': float(sort_scores[j]), 'image_id': int(res['image_id'].split('.jpg')[0].split('_000000')[-1]), + 'category_id': int(classes_originID[LABEL_NAME_MAP[sort_labels[j]]])}) + + pbar.set_description("Eval image %s" % res['image_id']) + + pbar.update(1) + + for p in procs: + p.join() + + json.dump(coco_det, fw_json_dt) + fw_json_dt.close() + return os.path.join(save_path, 'coco_minival.json') + + +def eval(num_imgs, eval_data, eval_gt, gpu_ids): + + with open(eval_data) as f: + test_img_list = f.readlines() + + if num_imgs == np.inf: + real_test_img_list = test_img_list + else: + real_test_img_list = test_img_list[: num_imgs] + + faster_rcnn = build_whole_network.DetectionNetwork(base_network_name=cfgs.NET_NAME, + is_training=False) + detected_json = eval_coco(det_net=faster_rcnn, real_test_img_list=real_test_img_list, gpu_ids=gpu_ids) + + # save_path = os.path.join('./eval_coco', cfgs.VERSION) + # detected_json = os.path.join(save_path, 'coco_minival.json') + cocoval(detected_json, eval_gt) + + +def parse_args(): + + parser = argparse.ArgumentParser('evaluate the result with Pascal2007 stdand') + + parser.add_argument('--eval_data', dest='eval_data', + help='evaluate imgs dir ', + default='coco_minival2014.odgt', type=str) + parser.add_argument('--eval_gt', dest='eval_gt', + help='eval gt', + default='instances_minival2014.json', + type=str) + parser.add_argument('--gpus', dest='gpus', + help='gpu id', + default='0,1,2,3,4,5,6,7', type=str) + parser.add_argument('--eval_num', dest='eval_num', + help='the num of eval imgs', + default=np.inf, type=int) + args = parser.parse_args() + return args + + +if __name__ == '__main__': + + # args = parse_args() + # print(20*"--") + # print(args) + # print(20*"--") + # eval(args.eval_num, # use np.inf to test all the imgs. use 10 to test 10 imgs. + # eval_data=args.eval_data, + # eval_gt=args.eval_gt, + # gpu_ids=args.gpus) + + # os.environ["CUDA_VISIBLE_DEVICES"] = cfgs.GPU_GROUP + eval(np.inf, # use np.inf to test all the imgs. use 10 to test 10 imgs. + eval_data='/data/COCO/coco_minival2014.odgt', + eval_gt='/data/COCO/instances_minival2014.json', + gpu_ids='0,1,2,3,4,5,6,7') + + + + + + + + + + + + + + + + diff --git a/tools/inference.py b/tools/inference.py new file mode 100644 index 0000000..a7f6789 --- /dev/null +++ b/tools/inference.py @@ -0,0 +1,151 @@ +# -*- 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) + if cfgs.NET_NAME in ['resnet152_v1d', 'resnet101_v1d', 'resnet50_v1d']: + img_batch = (img_batch / 255 - tf.constant(cfgs.PIXEL_MEAN_)) / tf.constant(cfgs.PIXEL_STD) + else: + 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.VIS_SCORE + show_scores = detected_scores[show_indices] + show_boxes = detected_boxes[show_indices] + show_categories = detected_categories[show_indices] + + draw_img = np.squeeze(resized_img, 0) + + if cfgs.NET_NAME in ['resnet152_v1d', 'resnet101_v1d', 'resnet50_v1d']: + draw_img = (draw_img * np.array(cfgs.PIXEL_STD) + np.array(cfgs.PIXEL_MEAN_)) * 255 + else: + draw_img = draw_img + np.array(cfgs.PIXEL_MEAN) + final_detections = draw_box_in_img.draw_boxes_with_label_and_scores(draw_img, + boxes=show_boxes, + labels=show_categories, + scores=show_scores, + in_graph=False) + 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/tools/inference_for_coco.py b/tools/inference_for_coco.py new file mode 100644 index 0000000..53bc27d --- /dev/null +++ b/tools/inference_for_coco.py @@ -0,0 +1,189 @@ +# -*- 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) + if cfgs.NET_NAME in ['resnet152_v1d', 'resnet101_v1d', 'resnet50_v1d']: + img_batch = (img_batch / 255 - tf.constant(cfgs.PIXEL_MEAN_)) / tf.constant(cfgs.PIXEL_STD) + else: + 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.VIS_SCORE + show_scores = detected_scores[show_indices] + show_boxes = detected_boxes[show_indices] + show_categories = detected_categories[show_indices] + + draw_img = np.squeeze(resized_img, 0) + + if cfgs.NET_NAME in ['resnet152_v1d', 'resnet101_v1d', 'resnet50_v1d']: + draw_img = (draw_img * np.array(cfgs.PIXEL_STD) + np.array(cfgs.PIXEL_MEAN_)) * 255 + else: + draw_img = draw_img + np.array(cfgs.PIXEL_MEAN) + final_detections = draw_box_in_img.draw_boxes_with_label_and_scores(draw_img, + boxes=show_boxes, + labels=show_categories, + scores=show_scores, + in_graph=False) + 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/tools/inference_results/000058.jpg b/tools/inference_results/000058.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d266e49054226e02a01abc82f77c229d42b84fc0 GIT binary patch literal 226900 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

    y+70?*HGi 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�U(E~qi%EejRW1rJB>zVv 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

    2wYATqeCg1l`OpQ&h}dh)3(Hi_=RzftlSKK}I^+ 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%0DD{5ZUe1&DnWN`8#OoE{$yiKSPOw#ZbB0y-nn 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 literal 0 HcmV?d00001 diff --git a/tools/inference_results/000108.jpg b/tools/inference_results/000108.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b829940ffd8eb929d5ef148498eac9ee4068d3ec GIT binary patch literal 140913 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%0A&UdzaXjA!P_; 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

    Vv5S?Jh_D`XfzRgsm4-BfBVp2R$?MQw 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 Tq+TIyt|xE|-vOrG+Z+8KDvNt7 literal 0 HcmV?d00001 diff --git a/tools/inference_results/000237.jpg b/tools/inference_results/000237.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0cff4892595705539ec29c15c1b58f3b8e9b5cde GIT binary patch literal 212381 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 z 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 z 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 Yz!4;U%%jkr^ifW)!j4&0ntC7q*-(;E`Tzg` literal 0 HcmV?d00001 diff --git a/tools/inference_results/000449.jpg b/tools/inference_results/000449.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e19372a65bac92ee6b438d7cb970dbf6873bf4e9 GIT binary patch literal 160020 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

    }i8ICyK<&Zb_!r=PXT;ttx0Gqd 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

    Q()b<-8pm@^H)y%v7-?5RSrw9z2{#y~fH}0@ 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\&O#l8hVMOlrA@3_$1eUtJ-`w{WcC+z7mbixq)>$ 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

    }} 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 !_ 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

    o}WQ;YD#RzL|#zN~~^S46kmfYS} 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�yVRkBoqC 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 DT)xlg literal 0 HcmV?d00001 diff --git a/tools/inference_results/004640.jpg b/tools/inference_results/004640.jpg new file mode 100644 index 0000000000000000000000000000000000000000..93869242d85d0020ec6bb7dd2db54f20f9dda15a GIT binary patch literal 221240 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�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 1: + grads = sum_gradients(tower_grads) + else: + grads = tower_grads[0] + + # final_gvs = [] + # with tf.variable_scope('Gradient_Mult'): + # for grad, var in grads: + # scale = 1. + # # if '/biases:' in var.name: + # # scale *= 2. + # if 'conv_new' in var.name: + # scale *= 3. + # if not np.allclose(scale, 1.0): + # grad = tf.multiply(grad, scale) + # final_gvs.append((grad, var)) + + apply_gradient_op = optimizer.apply_gradients(grads, global_step=global_step) + + variable_averages = tf.train.ExponentialMovingAverage(0.9999, global_step) + variables_averages_op = variable_averages.apply(tf.trainable_variables()) + + train_op = tf.group(apply_gradient_op, variables_averages_op) + # train_op = optimizer.apply_gradients(final_gvs, global_step=global_step) + summary_op = tf.summary.merge_all() + + restorer, restore_ckpt = retinanet.get_restorer() + saver = tf.train.Saver(max_to_keep=25) + + init_op = tf.group( + tf.global_variables_initializer(), + tf.local_variables_initializer() + ) + + tfconfig = tf.ConfigProto( + allow_soft_placement=True, log_device_placement=False) + tfconfig.gpu_options.allow_growth = True + with tf.Session(config=tfconfig) as sess: + sess.run(init_op) + + # sess.run(tf.initialize_all_variables()) + coord = tf.train.Coordinator() + threads = tf.train.start_queue_runners(coord=coord, sess=sess) + + summary_path = os.path.join(cfgs.SUMMARY_PATH, cfgs.VERSION) + tools.mkdir(summary_path) + summary_writer = tf.summary.FileWriter(summary_path, graph=sess.graph) + + if not restorer is None: + restorer.restore(sess, restore_ckpt) + print('restore model') + + for step in range(cfgs.MAX_ITERATION // num_gpu): + 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]) + + else: + if step % cfgs.SHOW_TRAIN_INFO_INTE == 0 and step % cfgs.SMRY_ITER != 0: + start = time.time() + + _, global_stepnp, total_loss_dict_ = \ + sess.run([train_op, global_step, total_loss_dict]) + + end = time.time() + + print('***'*20) + print("""%s: global_step:%d current_step:%d""" + % (training_time, (global_stepnp-1)*num_gpu, step*num_gpu)) + print("""per_cost_time:%.3fs""" + % ((end - start) / num_gpu)) + loss_str = '' + for k in total_loss_dict_.keys(): + loss_str += '%s:%.3f\n' % (k, total_loss_dict_[k]) + print(loss_str) + + 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-1)*num_gpu) + summary_writer.flush() + + if (step > 0 and step % (cfgs.SAVE_WEIGHTS_INTE // num_gpu) == 0) or (step >= cfgs.MAX_ITERATION // num_gpu - 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, '{}_'.format(cfgs.DATASET_NAME) + str((global_stepnp-1)*num_gpu) + 'model.ckpt') + saver.save(sess, save_ckpt) + print(' weights had been saved') + + coord.request_stop() + coord.join(threads) + + +if __name__ == '__main__': + + train() + + + + + + + + + + diff --git a/tools/test.py b/tools/test.py new file mode 100644 index 0000000..b809062 --- /dev/null +++ b/tools/test.py @@ -0,0 +1,165 @@ +# -*- 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) + if cfgs.NET_NAME in ['resnet152_v1d', 'resnet101_v1d', 'resnet50_v1d']: + img_batch = (img_batch / 255 - tf.constant(cfgs.PIXEL_MEAN_)) / tf.constant(cfgs.PIXEL_STD) + else: + 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.VIS_SCORE + show_scores = detected_scores[show_indices] + show_boxes = detected_boxes[show_indices] + show_categories = detected_categories[show_indices] + draw_img = np.squeeze(resized_img, 0) + if cfgs.NET_NAME in ['resnet152_v1d', 'resnet101_v1d', 'resnet50_v1d']: + draw_img = (draw_img * np.array(cfgs.PIXEL_STD) + np.array(cfgs.PIXEL_MEAN_)) * 255 + else: + draw_img = draw_img + np.array(cfgs.PIXEL_MEAN) + + # draw_img = draw_img * (np.array(cfgs.PIXEL_STD)*255) + np.array(cfgs.PIXEL_MEAN) + + final_detections = draw_box_in_img.draw_boxes_with_label_and_scores(draw_img, + boxes=show_boxes, + labels=show_categories, + scores=show_scores, + in_graph=False) + 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/tools/test_coco.py b/tools/test_coco.py new file mode 100644 index 0000000..e70bb76 --- /dev/null +++ b/tools/test_coco.py @@ -0,0 +1,215 @@ +# -*- 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 +import json +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 +from libs.label_name_dict.label_dict import * + +from data.lib_coco.PythonAPI.pycocotools.coco import COCO +from data.lib_coco.PythonAPI.pycocotools.cocoeval import COCOeval + + +def test_coco(det_net, real_test_img_list, eval_data, 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) + if cfgs.NET_NAME in ['resnet152_v1d', 'resnet101_v1d', 'resnet50_v1d']: + img_batch = (img_batch / 255 - tf.constant(cfgs.PIXEL_MEAN_)) / tf.constant(cfgs.PIXEL_STD) + else: + img_batch = img_batch - tf.constant(cfgs.PIXEL_MEAN) + + # img_batch = (img_batch - tf.constant(cfgs.PIXEL_MEAN)) / (tf.constant(cfgs.PIXEL_STD)*255) + 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 + + with tf.Session(config=config) as sess: + sess.run(init_op) + if not restorer is None: + restorer.restore(sess, restore_ckpt) + print('restore model') + + save_path = os.path.join('./eval_coco', cfgs.VERSION) + tools.mkdir(save_path) + fw_json_dt = open(os.path.join(save_path, 'coco_test-dev.json'), 'w') + coco_det = [] + for i, a_img in enumerate(real_test_img_list): + + raw_img = cv2.imread(os.path.join(eval_data, a_img['file_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() + + eval_indices = detected_scores >= 0.01 + detected_scores = detected_scores[eval_indices] + detected_boxes = detected_boxes[eval_indices] + detected_categories = detected_categories[eval_indices] + + # print("{} cost time : {} ".format(img_name, (end - start))) + if draw_imgs: + show_indices = detected_scores >= cfgs.VIS_SCORE + show_scores = detected_scores[show_indices] + show_boxes = detected_boxes[show_indices] + show_categories = detected_categories[show_indices] + + draw_img = np.squeeze(resized_img, 0) + if cfgs.NET_NAME in ['resnet152_v1d', 'resnet101_v1d', 'resnet50_v1d']: + draw_img = (draw_img * np.array(cfgs.PIXEL_STD) + np.array(cfgs.PIXEL_MEAN_)) * 255 + else: + draw_img = draw_img + np.array(cfgs.PIXEL_MEAN) + + # draw_img = draw_img * (np.array(cfgs.PIXEL_STD)*255) + np.array(cfgs.PIXEL_MEAN) + + final_detections = draw_box_in_img.draw_boxes_with_label_and_scores(draw_img, + boxes=show_boxes, + labels=show_categories, + scores=show_scores, + in_graph=False) + if not os.path.exists(cfgs.TEST_SAVE_PATH): + os.makedirs(cfgs.TEST_SAVE_PATH) + + cv2.imwrite(cfgs.TEST_SAVE_PATH + '/' + '{}.jpg'.format(a_img['id']), + 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])) + + # cost much time + for j, box in enumerate(boxes): + coco_det.append({'bbox': [float(box[0]), float(box[1]), float(box[2]), float(box[3])], + 'score': float(detected_scores[j]), 'image_id': a_img['id'], + 'category_id': int(classes_originID[LABEL_NAME_MAP[detected_categories[j]]])}) + + tools.view_bar('%s image cost %.3fs' % (a_img['id'], (end - start)), i + 1, len(real_test_img_list)) + + json.dump(coco_det, fw_json_dt) + fw_json_dt.close() + + +def eval(num_imgs, eval_data, json_file, showbox): + + with open(json_file) as f: + test_img_list = json.load(f)['images'] + + if num_imgs == np.inf: + real_test_img_list = test_img_list + else: + real_test_img_list = test_img_list[: num_imgs] + + faster_rcnn = build_whole_network.DetectionNetwork(base_network_name=cfgs.NET_NAME, + is_training=False) + test_coco(det_net=faster_rcnn, real_test_img_list=real_test_img_list, eval_data=eval_data, draw_imgs=showbox) + + +def parse_args(): + + parser = argparse.ArgumentParser('evaluate the result with Pascal2007 stdand') + + parser.add_argument('--eval_data', dest='eval_data', + help='evaluate imgs dir ', + default='/unsullied/sharefs/_research_detection/GeneralDetection/COCO/data/MSCOCO/odformat/coco_minival2014.odgt', type=str) + parser.add_argument('--json_file', dest='json_file', + help='test-dev json file', + default='/home/yangxue/isilon/yangxue/code/yxdet/FPN_Tensorflow/tools/image_info_test-dev2017.json', 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='0', type=str) + parser.add_argument('--eval_num', dest='eval_num', + help='the num of eval imgs', + default=np.inf, 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_data=args.eval_data, + # eval_gt=args.eval_gt, + # showbox=args.showbox) + + os.environ["CUDA_VISIBLE_DEVICES"] = '0' + eval(np.inf, # use np.inf to test all the imgs. use 10 to test 10 imgs. + eval_data='/unsullied/sharefs/yangxue/isilon/yangxue/data/COCO/test2017', + json_file='/home/yangxue/isilon/yangxue/code/yxdet/FPN_TF_DEV/tools/image_info_test-dev2017.json', + showbox=False) + + # cocoval('./eval_coco/FPN_Res101_20190108_v1/coco_res.json', + # '/unsullied/sharefs/_research_detection/GeneralDetection/COCO/data/MSCOCO/instances_minival2014.json') + + + + + + + + + + + + + + + + + + + diff --git a/tools/test_coco_multiprocessing.py b/tools/test_coco_multiprocessing.py new file mode 100644 index 0000000..cc0e9a3 --- /dev/null +++ b/tools/test_coco_multiprocessing.py @@ -0,0 +1,209 @@ +# -*- coding:utf-8 -*- + +from __future__ import absolute_import +from __future__ import print_function +from __future__ import division + +import os +import sys +import tensorflow as tf +import time +import cv2 +import numpy as np +import json +import math +from tqdm import tqdm +import argparse +from multiprocessing import Queue, Process +sys.path.append("../") + +from data.io.image_preprocess import short_side_resize_for_inference_data +from libs.networks import build_whole_network +from help_utils import tools +from libs.label_name_dict.label_dict import * + + +def worker(gpu_id, images, det_net, eval_data, result_queue): + os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id) + # 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) + if cfgs.NET_NAME in ['resnet152_v1d', 'resnet101_v1d', 'resnet50_v1d']: + img_batch = (img_batch / 255 - tf.constant(cfgs.PIXEL_MEAN_)) / tf.constant(cfgs.PIXEL_STD) + else: + 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 + + with tf.Session(config=config) as sess: + sess.run(init_op) + if not restorer is None: + restorer.restore(sess, restore_ckpt) + print('restore model %d ...' % gpu_id) + for a_img in images: + raw_img = cv2.imread(os.path.join(eval_data, a_img['file_name'])) + raw_h, raw_w = raw_img.shape[0], raw_img.shape[1] + + 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]} + ) + + resized_h, resized_w = resized_img.shape[1], resized_img.shape[2] + scales = [raw_w / resized_w, raw_h / resized_h] + result_dict = {'scales': scales, 'boxes': detected_boxes, + 'scores': detected_scores, 'labels': detected_categories, + 'image_id': a_img['id']} + result_queue.put_nowait(result_dict) + + +def test_coco(det_net, real_test_img_list, eval_data, gpu_ids): + + save_path = os.path.join('./eval_coco', cfgs.VERSION) + tools.mkdir(save_path) + fw_json_dt = open(os.path.join(save_path, 'coco_test-dev.json'), 'w') + coco_det = [] + + nr_records = len(real_test_img_list) + pbar = tqdm(total=nr_records) + gpu_num = len(gpu_ids.strip().split(',')) + + nr_image = math.ceil(nr_records / gpu_num) + result_queue = Queue(500) + procs = [] + + for i in range(gpu_num): + start = i * nr_image + end = min(start + nr_image, nr_records) + split_records = real_test_img_list[start:end] + proc = Process(target=worker, args=(i, split_records, det_net, eval_data, result_queue)) + print('process:%d, start:%d, end:%d' % (i, start, end)) + proc.start() + procs.append(proc) + + for i in range(nr_records): + res = result_queue.get() + + xmin, ymin, xmax, ymax = res['boxes'][:, 0], res['boxes'][:, 1], \ + res['boxes'][:, 2], res['boxes'][:, 3] + + xmin = xmin * res['scales'][0] + xmax = xmax * res['scales'][0] + + ymin = ymin * res['scales'][1] + ymax = ymax * res['scales'][1] + + boxes = np.transpose(np.stack([xmin, ymin, xmax-xmin, ymax-ymin])) + + for j, box in enumerate(boxes): + coco_det.append({'bbox': [float(box[0]), float(box[1]), float(box[2]), float(box[3])], + 'score': float(res['scores'][j]), 'image_id': res['image_id'], + 'category_id': int(classes_originID[LABEL_NAME_MAP[res['labels'][j]]])}) + + pbar.set_description("Test image %s" % res['image_id']) + + pbar.update(1) + + for p in procs: + p.join() + + json.dump(coco_det, fw_json_dt) + fw_json_dt.close() + + +def eval(num_imgs, eval_data, json_file, gpu_ids): + + with open(json_file) as f: + test_img_list = json.load(f)['images'] + + if num_imgs == np.inf: + real_test_img_list = test_img_list + else: + real_test_img_list = test_img_list[: num_imgs] + + faster_rcnn = build_whole_network.DetectionNetwork(base_network_name=cfgs.NET_NAME, + is_training=False) + test_coco(det_net=faster_rcnn, real_test_img_list=real_test_img_list, eval_data=eval_data, gpu_ids=gpu_ids) + + +def parse_args(): + + parser = argparse.ArgumentParser('evaluate the result with Pascal2007 stdand') + + parser.add_argument('--eval_data', dest='eval_data', + help='evaluate imgs dir ', + default='/data/COCO/test2017', type=str) + parser.add_argument('--json_file', dest='json_file', + help='test-dev json file', + default='image_info_test-dev2017.json', type=str) + parser.add_argument('--showbox', dest='showbox', + help='whether show detecion results when evaluation', + default=False, type=bool) + parser.add_argument('--gpus', dest='gpus', + help='gpu id', + default='0,1,2,3,4,5,6,7', type=str) + parser.add_argument('--eval_num', dest='eval_num', + help='the num of eval imgs', + default=np.inf, 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_data=args.eval_data, + # eval_gt=args.eval_gt, + # gpu_ids=args.gpus) + + # os.environ["CUDA_VISIBLE_DEVICES"] = '0' + eval(np.inf, # use np.inf to test all the imgs. use 10 to test 10 imgs. + eval_data='/data/COCO/test2017', + json_file='/data/COCO/annotation/image_info_test-dev2017.json', + gpu_ids='0,1,2,3') + + # cocoval('./eval_coco/FPN_Res101_20190108_v1/coco_res.json', + # '/unsullied/sharefs/_research_detection/GeneralDetection/COCO/data/MSCOCO/instances_minival2014.json') + + + + + + + + + + + + + + + + + + + diff --git a/tools/train.py b/tools/train.py new file mode 100644 index 0000000..4d7aa95 --- /dev/null +++ b/tools/train.py @@ -0,0 +1,172 @@ +# -*- 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_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"] = cfgs.GPU_GROUP + + +def train(): + retinanet = 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]) + if cfgs.NET_NAME in ['resnet152_v1d', 'resnet101_v1d', 'resnet50_v1d']: + img_batch = img_batch / tf.constant([cfgs.PIXEL_STD]) + + final_bbox, final_scores, final_category, loss_dict = retinanet.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()) + cls_loss = loss_dict['cls_loss'] + reg_loss = loss_dict['reg_loss'] + total_loss = cls_loss + reg_loss + weight_decay_loss + + # ---------------------------------------------------------------------------------------------------add summary + tf.summary.scalar('RETINANET_LOSS/cls_loss', cls_loss) + tf.summary.scalar('RETINANET_LOSS/reg_loss', reg_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) + + 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 = retinanet.get_gradients(optimizer, total_loss) + + # enlarge_gradients for bias + if cfgs.MUTILPY_BIAS_GRADIENT: + gradients = retinanet.enlarge_gradients_for_bias(gradients) + + if cfgs.GRADIENT_CLIPPING_BY_NORM: + with tf.name_scope('clip_gradients'): + gradients = slim.learning.clip_gradient_norms(gradients, + cfgs.GRADIENT_CLIPPING_BY_NORM) + + # 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 = retinanet.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') + coord = tf.train.Coordinator() + threads = tf.train.start_queue_runners(sess, coord) + + summary_path = os.path.join(cfgs.SUMMARY_PATH, cfgs.VERSION) + if not os.path.exists(summary_path): + os.makedirs(summary_path) + summary_writer = tf.summary.FileWriter(summary_path, graph=sess.graph) + + for step in range(cfgs.MAX_ITERATION): + 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]) + + else: + if step % cfgs.SHOW_TRAIN_INFO_INTE == 0 and step % cfgs.SMRY_ITER != 0: + start = time.time() + + _, global_stepnp, img_name, reg_loss_, cls_loss_, total_loss_ = \ + sess.run( + [train_op, global_step, img_name_batch, reg_loss, cls_loss, total_loss]) + + end = time.time() + + print(""" {}: step{} image_name:{} |\t + reg_loss:{} |\t cls_loss:{} |\t total_loss:{} |per_cost_time:{}s""" \ + .format(training_time, global_stepnp, str(img_name[0]), reg_loss_, cls_loss_, total_loss_, + (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.makedirs(save_dir) + + save_ckpt = os.path.join(save_dir, '{}_'.format(cfgs.DATASET_NAME) + str(global_stepnp) + 'model.ckpt') + saver.save(sess, save_ckpt) + print(' weights had been saved') + + coord.request_stop() + coord.join(threads) + + +if __name__ == '__main__': + + train() + +# + + + + + + + + + + + + + + + + diff --git a/tools/train_with_placeholder.py b/tools/train_with_placeholder.py new file mode 100644 index 0000000..3429aa6 --- /dev/null +++ b/tools/train_with_placeholder.py @@ -0,0 +1,231 @@ +# -*- 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) + if cfgs.NET_NAME in ['resnet152_v1d', 'resnet101_v1d', 'resnet50_v1d']: + img = img / 255 - tf.constant([[cfgs.PIXEL_MEAN_]]) + else: + 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) + + # 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, '{}_'.format(cfgs.DATASET_NAME) + str(global_stepnp) + 'model.ckpt') + saver.save(sess, save_ckpt) + print(' weights had been saved') + + +if __name__ == '__main__': + + train() + +# + + + + + + + + + + + + + + + +

    PN!F|I4) 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 literal 0 HcmV?d00001 diff --git a/tools/demos/000719.jpg b/tools/demos/000719.jpg new file mode 100644 index 0000000000000000000000000000000000000000..927b1b135c338c01f5caf7fae18acc538feb9327 GIT binary patch literal 108797 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